Skip to main content
Glama

AI assistant editor for Premiere Pro and DaVinci Resolve

premiere-claude-bridge is a free, open-source MCP server that lets Claude Code or Codex do the assistant editor's work inside your own project. You ask in plain language. It logs the footage, transcribes the speech, lays out a rough cut on your timeline and checks the result before you ship it.

License: MIT MCP Status: Beta PRs Welcome

Real session: one prompt, Claude assembles a vertical reel in Premiere Pro

Real session, no cuts: one request in Claude, and the bridge imports the clips, builds the vertical sequence, lays the shots on the timeline and adds markers and captions. Watch the mp4.

Install in one sentence

Open Claude Code (the Code tab of the Claude desktop app works) and send it this:

Install premiere-claude-bridge from github.com/koptsev63/premiere-claude-bridge following its README, and take me to the green "Connected" label in Premiere.

Claude clones the repo, sets everything up and tells you when to restart Premiere. Then:

  1. In Premiere open Window → Extensions → Claude Bridge. The panel should say "Connected to Claude".

  2. Start a new chat and ask: "Check the connection to Premiere."

  3. Keep that Claude session open while you edit.

On DaVinci Resolve Studio there is no panel. Set Preferences → System → General → External scripting using to Local, restart Resolve, and ask Claude to set the project up for Resolve.

You need Premiere Pro 2024 or newer, or DaVinci Resolve Studio, and a Claude or Codex subscription. Tested on macOS. Windows has install steps but nobody has confirmed them yet. Prefer to do it by hand? See Manual install.

Related MCP server: fcp-mcp-server

For editors (Russian-speaking users)

How to install. Open Claude (the app, Code tab) and send it this phrase: "Install the Premiere bridge from github.com/koptsev63/premiere-claude-bridge and take me to the green Connected label in Premiere." Claude does the rest and tells you when to restart Premiere.

How to work. In Premiere open Window → Extensions → Claude Bridge. The panel should be green. Talk to Claude in plain words: "build a 1080 by 1920 sequence from this file", "put markers on the pauses", "open all the podcast sequences in tabs".

How to update. Tell Claude: "update the bridge". Then close and reopen Claude, and in Premiere close and reopen the panel. When a new version is out, Claude says so when it checks the connection.

If Premiere does not respond. Most often Premiere has a dialog open that is waiting for a click. Ask Claude: "Is Premiere waiting for a click?" It will name the window and the button.

If a video arrives with no picture. Clips from YouTube are often in a format that Premiere opens without an image. Just ask Claude to import the file: the bridge checks it beforehand and makes a working copy if needed.

Help train the assistant. The panel has a checkbox "Help train the assistant", on by default since version 0.8.3. The bridge sends an anonymized outline of the edit: where the cuts are, how many takes were shot, shot lengths. No video, no audio, no names. Only work done after the bridge update is sent. If you do not want this, uncheck the box or tell Claude "do not send the journal". A project under NDA can be excluded: the checkbox "Do not send this project" or the phrase "do not send this project" to Claude. If you turn off the main checkbox, everything already sent is deleted. Details and the privacy policy: DATA.md.

Editors' chat. Questions, bugs, wishes, techniques: t.me/+Fw5nSiqUkCswNjBi

What you can ask it to do

Sort the footage

  • Watch a whole folder of rushes and write a log: what is in the shot, where the motion and the sound are, which clips are shaky or tilted. You get one page with a frame strip per clip.

  • Transcribe speech offline, in Russian, English, Hungarian and other languages, then flag the words it probably misheard.

  • Find material by words: a character's lines, a topic, "the long monologue at night".

Build the cut

  • Put takes on the timeline in order and mark the story beats.

  • Cut out pauses and dead air.

  • Pick the strongest moments of a long recording for a short version.

  • Build two contrasting rough cuts from the same material so you choose.

  • Make variants of a cut you built by hand: drop a scene, insert a block, keep every other frame where it was.

Sound and subtitles

  • Duck music under speech and level the takes against each other.

  • Deliver subtitles as SRT and burned in.

Colour and hand-off to the colourist

  • Match camera, AI-generated and drone shots to one colour point, shot by shot, then bake three looks as LUTs and render them with ffmpeg.

  • Pull a "kolbasa" for grading from an editor's Resolve .drt: every shot relinked to the camera originals, grade removed, ProRes 422 HQ. It stops before the render if one shot out of eighty does not match the editor's cut.

Check before delivery

  • Refuse a grade with blown highlights or red skin, and a grade nobody can see.

  • Refuse a file with wrong proportions, shaky edges or no sound.

Follow your hands. Move the cuts, retype a caption, save the project. It reads your saved .prproj and works from your version from then on.

It has no taste. Decisions stay with you; it takes the logging, sorting and checking.

What an editor said

"Everything installed by your instruction with no problems. The only snag was setting up the first connection."

"So far I have used the assistant only for basic organisation of files on the timeline, like putting takes in chronological order and cutting the empty phases. It handled that very well, it is all quite intuitive."

Andrey, film editor, October 2026

The snag he hit is now step 2 above.

New in 0.4: the wrong shot nobody sees

A real Sunday on a festival teaser. The editor cut it in Resolve on proxies and sent a .drt. The colourist needed the same cut on the 4K S-Log3 camera originals. The import looked clean and the length matched to the frame. One shot of 79 was still wrong, and it went out three times:

  1. Resolve put a crowd shot where the editor had an orbit around the hero.

  2. The "fix" trusted the number in the .drt and put in a third shot.

  3. The editor sent the timecode, and only then was the shot right.

A contact sheet with a frame every seven seconds cannot see a three-second shot. So core/drt_audit.py reads the cut twice, once from the .drt and once from what the NLE actually laid down, and compares them clip by clip. If they disagree, it does not render. It prints both readings and asks you for the editor's timecode. Neither file is the truth. The editor is. A clip the editor played backwards or retimed is read through Resolve's speed map, not its In field: a reverse goes into the pull as the forward source piece with a note to flip it back, any other speed change stops for the editor's timecode.

Same release: core/shotmatch.py pulls camera, AI and drone shots to one colour point and bakes the result into LUTs, about 60 times faster than grading every frame in Python. Details in CHANGELOG.

Demo

The clip at the top of this page is a real 23-second session: a vertical reel assembled from one request. Below, the same thing as text:

You:    "Open Premiere. Import all .MTS from ~/Desktop/Footage/.
        Create a 1080p25 sequence called 'Rough'. Place clips
        00118 (1-6s), 00149 (4-9s), 00130 (1-5s) on V1 in order.
        Add markers at every emotional beat per Murch's hierarchy."

Claude: ✓ Imported 108 clips into bin '01_Source_MTS'
        ✓ Created Rough - 1920x1080, 25fps, 3 V / 6 A tracks
        ✓ Placed 3 clips on V1, total 14 sec
        ✓ Marked 5 emotional beats: HOOK @0s, COMEDY @5s,
          PIT @8s, BREATH @11s, PAYOFF @13s

→ Real output from this exact prompt. See examples/grave-stakes-teaser/cutlist_v3.json for the full 12-clip cutlist that built the case-study teaser.

How this compares to other Premiere and Resolve MCP servers

There are about fifteen Premiere MCP servers on GitHub now, and several for Resolve. The big ones are good at something this project is not, so here is the honest split (checked October 2026).

Where the others are ahead

  • Typed timeline tools. hetpatel-11/Adobe_Premiere_Pro_MCP and leancoderkavy/premiere-pro-mcp ship hundreds of typed tools for effects, keyframes, transitions and multicam. Here those go through pr_eval_jsx.

  • Install. They have npm packages and installers. This repo is a clone and a symlink.

  • UXP. Both have a UXP preview. This panel is CEP only.

  • Resolve depth. samuelgursky/davinci-resolve-mcp covers Fusion, Fairlight and the free edition. This project needs Resolve Studio and is tested on macOS.

What this project does that their READMEs do not mention

Your edits come back

Reads the saved .prproj and conforms every later render to what you changed by hand

Gates that refuse

Colour, loudness and delivery checks raise an error instead of shipping a bad file

Work before the timeline

Auto-log of raw footage, offline transcript, dead-air removal, two rough-cut variants, subtitles

An editing method

Walter Murch's Rule of Six as decision rules in skills/film-editing/SKILL.md

One brain, two editors

The same cut list goes to Premiere or Resolve

Small surface

35 tools, one of them the escape hatch pr_eval_jsx: a few dozen, not hundreds, so the model does not need a tool search to find its way

If you need an agent that can reach every button in Premiere, pick one of the big servers. If you want an assistant editor for documentary material that checks its own output and follows your manual changes, this one is for you.

Why I built this

I'm a film director (festival shorts, currently developing two features in screenplay labs - Doukhobors in TFL Next, Grave Stakes in Cinéfondation). I monkey with Adobe Premiere all the time, and I burn 4-6 hours per teaser on the same boring assistant-editor work: watching all the dailies, writing notes in Excel, dragging selects to a timeline, trimming, re-timing.

I tried Adobe's own AI tools. Their official Creative Cloud connector advertises "Premiere capabilities" but the actual surface is four cloud video tools that have nothing to do with the desktop app. The Adobe docs themselves say: for trim by timestamp, use Adobe Premiere. So I made the thing that actually does that.

The non-obvious bit: I didn't want a chatbot that randomly clicks buttons. I wanted one that thinks like an editor. So the core of this repo is skills/film-editing/SKILL.md - Walter Murch's In the Blink of an Eye compressed into machine-actionable decision rules. Every cut my AI assistant proposes ranks Emotion > Story > Rhythm > Eye-trace > 2D > 3D, and I can override per shot.

It worked on my actual Grave Stakes teaser. I wanted other directors and editors to have the same thing without re-implementing the bridge from scratch.

Honest limitations

The bridge gives Claude full programmatic control of Premiere. With the watch skill bundled, the previous "stop-frames only" limitation is largely closed. What remains:

  • Sub-frame timing intuition. Murch-level "trim 8 frames" calls still need a human editor.

  • Micro-expression nuance. Frames + transcript get you 80% of the way; the last 20% is taste.

  • Dramaturgy from nothing. Structure must be specified - the skill won't invent the through-line.

Position it as: senior assistant editor + automation, not director's editor.


For developers

Manual install

Prerequisites

You pick one agent and one NLE - the bridge connects them:

  • Agent: Claude Code or OpenAI Codex (both speak MCP) - or any MCP-compatible client

  • NLE: Adobe Premiere Pro 2024+ or DaVinci Resolve Studio (the paid Studio - the free edition has no scripting API or stabilizer). Premiere runs on macOS/Windows; the Resolve path is tested on macOS.

  • Node.js 20+ for the MCP server

  • Python 3.11+ + ffmpeg for the analysis tools (camera-shake + horizon need OpenCV: pip install opencv-python-headless)

You drive it by talking in plain language - no commands to memorize. The terminal is only for the one-time install.

1. Clone and install

git clone https://github.com/koptsev63/premiere-claude-bridge.git
cd premiere-claude-bridge
cd mcp-server && npm install && cd ..

2. Register the MCP server

Add to your ~/.claude.json (Claude Code) or your client's MCP config:

{
  "mcpServers": {
    "premiere": {
      "command": "node",
      "args": ["/absolute/path/to/premiere-claude-bridge/mcp-server/server.js"]
    }
  }
}

3. Install the CEP panel into Premiere

macOS:

defaults write com.adobe.CSXS.11 PlayerDebugMode 1
defaults write com.adobe.CSXS.12 PlayerDebugMode 1
ln -sf "$(pwd)/cep-extension" \
  ~/Library/Application\ Support/Adobe/CEP/extensions/com.koptsev.claude-bridge

Windows (PowerShell admin):

New-ItemProperty -Path "HKCU:\Software\Adobe\CSXS.11" -Name PlayerDebugMode -Value 1 -PropertyType String -Force
New-ItemProperty -Path "HKCU:\Software\Adobe\CSXS.12" -Name PlayerDebugMode -Value 1 -PropertyType String -Force
mklink /D "$env:APPDATA\Adobe\CEP\extensions\com.koptsev.claude-bridge" "$(Get-Location)\cep-extension"

Restart Premiere → Window → Extensions → Claude Bridge → green "Connected to Claude".

First connection (where people get stuck)

  1. Keep a Claude Code session open. The MCP server is a child process of your Claude session. Close the session (or the Code tab in the desktop app) and the panel drops to "Disconnected".

  2. Start a new chat after installing. A session only loads MCP servers when it starts, so the chat you installed from does not see the bridge yet.

  3. Ask for a health check first: "Use pr_status to check the bridge." A reply with your Premiere version and project name means everything is wired up.

4. (Optional) Enable the analysis tools

pip install -U pillow opencv-python-headless openai-whisper
brew install yt-dlp ffmpeg          # macOS
# Linux: sudo apt install ffmpeg && pip install yt-dlp

openai-whisper is the offline transcription backend for /watch - no API key needed, works on Hungarian/Russian/etc. far better than the cloud whisper-1.

→ Detailed install + troubleshooting: docs/install.md

Tools (MCP commands Claude can call)

Tool

What it does

pr_status

Bridge health check + Premiere version + active project info

pr_get_project_info

List all bins + project items (with nodeId for reference)

pr_get_active_sequence

Sequence dimensions, fps, track count

pr_list_timeline

Full track-by-track clip dump (in/out, start/end, duration)

pr_get_selected

Currently selected clips on timeline

pr_get_playhead / pr_set_playhead

CTI control

pr_add_marker

Place marker at given time with name + comment

pr_export_ame

Queue export to Adobe Media Encoder with .epr preset (Match Source; proxy presets refused)

pr_import_captions

Import .srt files one at a time, a caption track for each

pr_list_video_effects

Effect names as this Premiere knows them (localized UI)

pr_add_video_effect

Add an effect by English or local name, verified by component count

pr_eval_jsx

Escape hatch - run any ExtendScript code, last expression returned

pr_ping / pr_dialog_check

Cheap health; "is Premiere waiting for a click?" (modal window detector, 0.6)

pr_probe_media / pr_import_media

Codec and disk gate (AV1/VP9 come in as sound only), H.264 copy of a range, import one file per call

pr_make_sequence

Sequence from a clip range without any dialog: size, fps, bin; settings read back

pr_set_motion / pr_set_motion_keyframes

Scale / Position / Rotation on a clip, in pixels; hold keyframes for shot changes

pr_add_markers / pr_list_markers

Markers in bulk, count verified

pr_open_sequences / pr_activate_sequence

Tabs and the active sequence

pr_get_timeline / pr_get_inout

Any sequence's clips with borders in seconds; the render range after a manual trim

pr_delete_sequence / pr_move_to_bin / pr_list_bin / pr_save_project

Project housekeeping

pr_build_sequences

Many sequences from one spec: import, create, motion, keyframes, markers, open

pr_share / pr_update_bridge

Help train the assistant (on by default since 0.8.3, off with one click, see DATA.md); update in one sentence: "update the bridge"

pr_journal_snapshot / pr_journal_report

The editor's journal (0.7): snapshots of every sequence, diffs as editing decisions, the hand report

→ Full tool reference + ExtendScript recipes: docs/tools.md

  • Updates. pr_status says when a new release is out. The editor tells Claude "update the bridge"; pr_update_bridge pulls and reinstalls a git install (never touching local edits) or hands a Claude Desktop install the new .mcpb.

  • Updates arrive on their own (0.8.6). A git install moves itself to each new release in the background (fast-forward to the release tag, never over local edits or commits, only on the default branch); Claude says when a restart is needed. Off: pk.js update auto off or "do not update on your own". A Claude Desktop bundle still updates with "update the bridge".

  • Sharing the journal. On by default since 0.8.3, off with one click (panel checkbox) or one sentence to Claude; Claude tells the editor once. An earlier no stays a no. While on, every 10 minutes the bridge reads Premiere's new Auto-Save files and saved projects (found from Premiere's own recent projects list, so work done with Claude closed is caught up) and, since 0.8.7, DaVinci Resolve projects (each Project.db in Resolve's project library, read from a copy, plus project backups and .drp files in Resolve's backup folder) into the journal and sends new decisions and sequence shapes, anonymized with a salt that never leaves the machine. Only work done after the first run of 0.8.3 (or after turning it back on) is sent, and any project can be kept out for good (NDA): panel checkbox or "do not send this project". A later no deletes everything sent. pk.js share status | on | off | preview | send | doctor | exclude [project]; doctor says in words why nothing went. Full terms and privacy policy: DATA.md.

  • Editors' chat: t.me/+Fw5nSiqUkCswNjBi

New in 0.7: the editor's journal

The bridge used to see only what Claude sent through it. The editor's own hand - where he cuts, how many frames he takes off a head, how far an audio edit leads the picture - was never recorded. Now it is, as structure only (timecodes, clip names, media paths; no frames, no sound):

  • pk.js journal watch snapshots every sequence while Premiere runs (and once more on each save); pk.js journal import <Auto-Save folder> reads the same thing out of Premiere's autosaves, so a day of someone else's editing arrives as a zip and needs nothing installed on their side.

  • Two snapshots diff into decisions: trim_head, trim_tail, move, slip, split (a razor), speed, added, removed, move_track.

  • pk.js journal report --md / pr_journal_report: decisions by type, trim sizes in frames, razor count, tempo per active hour, and each sequence as it stands (V1 shot-length percentiles, histogram, cuts per minute, J/L cuts, gaps). The numbers feed the measured rules in skills/film-editing, the way a director's own cut already did.

Checked on 100 real autosaves of four projects (3811 decisions) and live on an open project. Ask the editor first; the journal is their work.

New in 0.6: sequences without a single click

Ten vertical shorts had to be built as Premiere sequences from one podcast (24.10.2026). Four things went wrong in a row, all of them now bridge functions:

  • createNewSequence(name, presetId) opened the "New Sequence" dialog and the bridge hung on a timeout. pr_make_sequence takes the dialog-free path (setInPoint/setOutPoint on the item, createNewSequenceFromClips, getSettings/setSettings) and reads the settings back.

  • The AV1 source from yt-dlp imported "successfully" with sound only. pr_import_media runs ffprobe first, refuses AV1/VP9/VP8/4:4:4, hands you the ffmpeg command for an H.264 copy of just the range you need (or runs it with convert: true), and refuses everything under 2 GB of free disk.

  • Any modal window froze every tool with no explanation. pr_dialog_check (and every 0.6 tool on a timeout) tells the difference: the panel's debug port still answers while the script thread is blocked, the extra on-screen window is named, and the message says which button to press, in Russian.

  • Motion keyframes lied twice: setInterpolationTypeAtKey with 5 is Bezier (hold is 4), and key times are media time (inPoint + t), while getValueAtTime answers consistently in whatever base you used. Both were caught by exporting frames and comparing them with the ffmpeg preview, not by the API. pr_set_motion_keyframes converts and holds.

Every one of these is also a pk.js command (node mcp-server/pk.js make-seq ...), so a session without the MCP panel has the same reach. The acceptance run: pr_build_sequences with a 10-sequence spec took 6 seconds and every sequence was verified by reading its timeline, Motion values and marker names back.

Direct path when several Claude sessions fight for the port

The MCP server owns one WebSocket port (9876) and the panel connects to whichever server instance holds it. Since 0.5.0 the session that calls a tool takes the port over, so this is rarely needed. It still helps while an older bridge (started before 0.5.0) sits on the port, or when you want to run a script without any MCP server at all.

mcp-server/pk.js does not use that port. It attaches to the panel's own Chromium debug endpoint (port 8088, declared in cep-extension/.debug and already enabled by the PlayerDebugMode install step) and calls evalScript the same way the panel does. Any number of sessions can use it at once.

node mcp-server/pk.js info                       # version, project, active sequence
node mcp-server/pk.js eval 'app.project.name'    # one ExtendScript expression
node mcp-server/pk.js file build_sequence.jsx    # a whole script
echo 'app.version' | node mcp-server/pk.js eval -
node mcp-server/pk.js status                     # 0.6: health + "is Premiere waiting for a click?"
node mcp-server/pk.js make-seq --name "PODCAST 01" --file /abs/clip.mp4 --in 10 --out 43.6 --w 1080 --h 1920 --fps 29.97 --bin "PODCAST shorts"
node mcp-server/pk.js build --spec spec.json     # many sequences from one spec

node mcp-server/pk.js with no arguments lists every typed command (probe, import, make-seq, motion, motion-keys, markers, open, activate, timeline, inout, delete-seq, move, ls, build, save). They share mcp-server/lib/ops.js with the MCP tools, so the behaviour is the same on both paths.

Node 22+ needs no packages for it; older Node uses the ws that npm install already put in mcp-server/. Premiere must be running with the Claude Bridge panel open. The result is the string evalScript returns, so have your script return JSON.stringify(...). Tell your agent: "if pr_status says the panel is not connected, use node mcp-server/pk.js".

The Resolve side has the same kind of hatch, plus eyes on the timeline: python -m core.adapters.resolve_run exec script.py runs your Python with resolve, project, timeline and mp preloaded, and still / grab return composited timeline frames as PNG.

The delivery loop (what actually ships a cut)

A render is not a delivery. The editor has to be able to open the work, disagree with it, and move a cut - so the loop closes back on the machine:

cutlist → sequences in the editor's own project → he edits and saves →
core.prproj reads his version → renders + grade conform to it →
core.colorgate passes it or sends it back

Module

What it is for

core/prproj.py

Reads a saved .prproj: sequences, caption cues, picture cuts. Razor halves are stitched back together against the cut list; untouched lines resolve from the sidecar by order, never by overlap (transcript time and cut time are different clocks)

core/colorgate.py

Two-sided colour gate. Upper: clipping, oversaturation, skin Cr and saturation against the base. Lower: mean CIE ΔE, so a look nobody can see fails too. assert_ok() raises instead of shipping

core/qc.py

Geometry and residual-shake gate on the rendered file, plus delivery integrity: decodes clean, promised size and rate, has sound

core/loudness.py

Levels the shots against each other, then one static gain and a true-peak limiter to the delivery target. Gate: integrated LUFS, true peak, spread between shots

core/screen_comp.py

Screen replacement: a clip composited into a phone, monitor or TV in the plate, riding an ECC camera track, with colour-exact Rec.709 I/O. Gate: the plate outside the screen must come back unchanged

core/adapters/resolve_run.py

Resolve from a shell: timeline dump, composited frames as PNG (still, grab), and exec for your own script

core/

The rest of the pipeline: cutlist IR, adapters, subtitles, ducking, denoise, highlights, beats

# does this grade burn the picture - or is it invisible?
python -m core.colorgate base.mov graded.mp4 --frames 8 --upto 60

# what did the human actually approve in there?
python -m core.prproj "reel.prproj" --srt subs.srt

# even out the takes, hit -14 LUFS / -1 dBTP, and prove it (exit 1 = do not ship)
python -m core.loudness master.mov deliver.mp4 --shots 0,5.6,11.2

# put a clip inside the TV in the shot
python -m core.screen_comp plate.mp4 content.mp4 out.mp4 --config screen.json

Skills

film-editing/

Walter Murch's editing operating system as Claude decision rules:

  • Rule of Six (Emotion 51% > Story 23% > Rhythm 10% > Eye-trace 7% > 2D 5% > 3D 4%)

  • Blink theory, misdirection, idea cuts, dreaming in pairs, decisive moment

  • Pacing tables for trailers/teasers/montage/interview/title cards

  • Russian↔English terminology mapping

Plus tooling:

  • tools/analyze_clips.py - folder → HTML contact sheet (motion + audio + horizon + strips)

  • tools/horizon_detect.py - sky-ground segmentation + Hough fallback for tilt detection

watch/ (vendored from bradautomates/claude-video, MIT)

Lets Claude actually watch a clip. Extracts 30-100 frames + transcript via three Whisper backends:

  • local (openai-whisper, no key, offline, free) - recommended

  • Groq whisper-large-v3 (cloud, fastest, ~$0.0002/min)

  • OpenAI whisper-1 (cloud, slowest, ~$0.006/min)

See skills/watch/ATTRIBUTION.md for credit and skills/film-editing/SKILL.md §XIV for integrated workflow.

dailies-prep/ and nle-handoff/ (add-ons by Denis Nazarov, 0.8.4)

The day's footage gets ready for the cut, and a Resolve cut travels on to Premiere and Avid:

  • dailies-prep: takes matched by timecode and MXF headers, recorder sound aligned to the camera by correlation with a confidence per link (core/dailies_sync.py), every timeline clip gets its own sound back inside Resolve (core/adapters/resolve_restore_sound.py), frame checks in steps from cheap to dense (core/framecheck.py).

  • nle-handoff: a .prproj built from the open Resolve project on top of a real Premiere project as a template (core/prproj_build.py, format notes in docs/prproj-format.md), an Avid bin with masters, sync and group clips (core/avb_build.py), a separate .avp (core/avp_build.py), AAF and XML checked before sending (core/handoff_check.py).

  • The skills are installed only after their plain-words ABOUT.md has been shown: python -m core.addons_install list, then describe <skill>, then install <skill> --yes.

Honest limits: the Premiere project, the Avid bin and the .avp have not been opened in the target applications yet, and projects saved by Premiere Pro 26 are not read as templates. The author's guide: docs/addons.md (Russian).

Architecture

How Claude drives Premiere - three processes, four hops

See docs/architecture.md. Notable design choices:

  • The calling session gets the panel - every Claude or Codex session starts its own server, and only one can hold port 9876. Since 0.5.0 the server that receives a tool call asks the holder to let go (HTTP on the same port), binds, and waits for the panel to reconnect; a holder in the middle of a request keeps the port until it is done. Nothing polls. A holder that is not a 0.5.0+ bridge is never touched: the error names its pid. mcp-server/pk.js still reaches the panel through its debug port (direct path).

  • ExtendScript JSON polyfill - Adobe never shipped JSON in their ES3 engine. Without the polyfill, every typed tool fails on JSON.stringify.

  • Self-healing socket lookup - adopts live wss.clients[0] if the cached panelSocket goes stale after a CEP panel reload.

These were all real bugs found during the Grave Stakes case study. See CHANGELOG.md.

Roadmap

  • v0.1 - MCP bridge + film-editing skill + analyze_clips

  • v0.2 - /watch skill bundled, local Whisper, horizon detection v2

  • v0.3 to v0.8 - shipped, see CHANGELOG.md

  • MCP Registry publish - official listing + GitHub Action for auto-release (since 0.8.2)

  • [~] trailer-bridge skill pack - 7 genre-specific recipes (action, drama, comedy, horror, doc, thriller, romance) + LUT presets + auto-rendering. Scaffold with the first recipes is in skills/trailer-bridge

  • Multicam audio sync - match camera angles by audio waveform xcorr, build multicam clips programmatically

  • Face/sentiment detection - mediapipe pass per clip → "where is the actor's most emotional moment in this take?"

  • [~] v1.0 - universal NLE core - editing brain decoupled from Premiere via an OpenTimelineIO cutlist; Premiere, DaVinci Resolve (Studio Python API), and Final Cut (FCPXML) become interchangeable backends (#6). Foundation landed in core/: cutlist IR + lossless OTIO round-trip, capability matrix, all three adapters, NLE-neutral review loop, 672 tests green. Resolve adapter verified end-to-end on Resolve Studio 21. Remaining: conform/proxy relink, capability-probe.

→ Want to claim one? Open an issue with claim label.

Why "universal NLE core" is not "the same bridge for every editor"

The three editors integrate in fundamentally different ways, so v1.0 is an adapter design, not a copy of the Premiere bridge (epic #6):

  • The editing brain stays NLE-agnostic. skills/film-editing/ (Murch's Rule of Six) and the /watch perception layer reason about footage and cuts, not about Premiere. They don't change.

  • One cutlist, expressed in OpenTimelineIO. A cut is decided once as an OTIO timeline (the cutlist_*.json in the Grave Stakes example, formalized). OTIO is the industry interchange standard - Resolve reads/writes it natively, FCPXML has OTIO adapters, Premiere goes through this bridge.

  • Thin per-NLE drivers, same verb set. Premiere = the existing CEP/ExtendScript bridge. DaVinci Resolve = direct Python via the official scripting API (requires Resolve Studio - external scripting is disabled in the free version). Final Cut = FCPXML round-trip (file exchange, not live control).

Net: a decision made once renders into any editor. Raw "AI controls Resolve" is already crowded (several MCP servers exist); the differentiator here is the editing operating system on top, not the driver underneath.

Contributing

PRs, issues, and skill packs are welcome - see CONTRIBUTING.md for the short guide.

Easiest ways to help:

  • 🐛 Open an issue if anything in the install steps doesn't work on your OS

  • 🎬 Submit a SKILL.md for a genre you know (music videos, podcasts, sports, weddings)

  • 📺 Record a 60-second screencast of your own use case → I'll pin it in the README

  • 🌐 Translate the film-editing SKILL.md to your language

Look for good first issue and help wanted labels.

Privacy

Journal sharing is on by default and off with one click on "Help train the assistant"; turning it off deletes everything sent. What goes, what never goes, who keeps it and how to delete it: DATA.md, the privacy policy.

License

MIT - see LICENSE. The vendored skills/watch/ is also MIT, copyright Bradley Bonanno - see skills/watch/ATTRIBUTION.md.

Status

🟡 Beta, v0.8.9. Tested end-to-end on real festival-bound documentary footage (Grave Stakes, 108 raw .MTS clips, 4.4 GB), then on a second production job start to finish - a vertical announcement reel cut in Premiere, conformed and graded through DaVinci Resolve, with the delivery loop above running on the director's own project file (August 2026). Three outside editors have it so far; the first one installed it on his own in October 2026.

Stuck on install or found a bug? Open an issue or a discussion here. News goes to the Telegram channel @koptsev_AI (in Russian).

Author: Vladimir Koptsev - film director, Barcelona. TG @koptsev_AI · koptsev63@gmail.com

  • core/hits.py - music accents (loud hits) and "cut on the hit" verification with a two-frame tolerance; core/xmeml.py - FCP7 XML writer for Premiere from a cutlist (0.5.1).

Tool Schema Changelog

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

Loading tool schema changelog…

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML, covering cut detection, silence removal, markers from transcripts and beats, role assignment, rough cuts, keyframes and speed ramps, cross-NLE export, and pushes straight into a running Final Cut Pro. Every write is journaled with its SHA-256 and can be undone, so edits stay non-destructive and reviewable.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from FCPXML — detecting cuts and flash frames, removing silence, placing markers from transcripts or beats, assigning roles, keyframing, retiming, and pushing cuts straight into a running Final Cut Pro. Every write is journaled and undoable, and timelines can be exported to other NLEs or delivered only after review.
      -
    • F
      license
      Not graded
      quality
      A
      maintenance
      Enables Claude to read, edit, and generate real Final Cut Pro timelines from exported FCPXML, covering cut detection, trims, splits, silence removal, markers, roles, transcript-based edits, keyframes and speed ramps, plus live pushes into a running Final Cut Pro. Every write is journaled, undoable, and guarded by SHA-256 checks so edits can be reviewed and delivered safely.
      -
    • A
      license
      C
      quality
      A
      maintenance
      Connects Claude to a running Adobe Premiere Pro via a CEP bridge, exposing hundreds of low-level project, sequence, clip, effect and export tools plus studio-grade workflows such as proxy generation, rough cuts from slate calls, text-based shot search, beat-driven cuts, per-scene colour, captions, aspect versions and delivery exports. All processing stays on the local Mac, with speech, vision and beat analysis handled by a companion media engine.
      317
      MIT