DaVinci Resolve

Let an AI agent edit, grade and deliver in DaVinci Resolve, with every change checked.

---

davinci-mcp is an MCP server for DaVinci Resolve. It gives AI agents such as Claude access to the whole Resolve scripting API: 299 typed actions across 17 domains. Every change is verified against Resolve itself before it is reported as done.

It is built for editors and colorists who want an assistant that does the clicking, and for developers who want a dependable bridge between an agent and Resolve.

See it work

A real Claude agent, given four plain messages, cut this 52-second action trailer from the open movie *Tears of Steel*. It imported the footage, laid out 33 shots on the beat, added the title cards, graded teal and orange, and rendered it. Nothing in the run was staged; the video below is sped up 4×.

▶ Watch the full demo on YouTube (39 s)

▶ Watch the trailer the agent cut on YouTube (52 s)

Why davinci-mcp

Verified, not hopeful

• Every write is read back from Resolve, and its receipt says verified: true or false. An agent can't claim a change that didn't happen.
• dry_run previews any write without applying it.
• Deletes need consent: the first call returns a plan and a confirm_token, and nothing is removed until the same call comes back with the token.
• Destructive edits take a safety snapshot of the timeline first.
• Every call is written to a JSONL audit log.

Reliable

• In the benchmark below, 20 of 20 jobs passed. The community MCP server passed 13 of 20, davinci-mcp-professional 10 of 20.
• Near-miss parameters are repaired instead of refused (fade_out → FadeOut, a bare clip name → a selector), and every rewrite is reported.
• Errors are actionable: they suggest the right field ("did you mean"), name the right tool, and say which render setting Resolve rejected.

Economical

• batch_run chains a whole sequence server-side in one call, for example 18 steps from timeline to render.
• Clients defer the tools, so the first turn costs about 32k tokens of context.
• Replies and schemas are compact. Against the community server: 31 % cheaper and 60 % fewer calls.

Exhaustive and extensible

• 17 domains: project, media, timeline, item, color, Fusion, gallery, audio, render, interchange, AI tools, UI, app and more.
• One-call workflows: conform_from_edl, deliver, build_vertical_reel, apply_look, title_overlay.
• Your own recipes: YAML templates, plus Python when you opt in.

Safe by default

• File access is limited to the folders you allow.
• The server's own state, its configuration and your Claude configuration files are always off-limits.
• Symlinks are never followed when importing a folder.

Benchmarks

Headless Claude agents (Sonnet) ran four post-production jobs on a live Resolve Studio 21.1, five runs each. An agent that never saw the server's code wrote the jobs:

• dailies: log and organise a day of footage;
• promo: build a promo with a music bed;
• look: grade with versions and a still;
• spot QC: duplicate, export interchange files and render a range.

Each check reads Resolve directly, never through the server under test. Every agent ran under the same isolated harness. Full method and history →

About the built-in server. Resolve 21.1 ships its own MCP server, which is cheaper because it hands the agent one tool, run_script_unsafe, to run arbitrary Python inside Resolve. That makes for short runs, but nothing is validated, read back, audited, snapshotted or confirmed before a delete. In our scale test (160 clips, 4 timelines) it once put a marker at the wrong frame, then reported the job done. davinci-mcp trades a little cost for changes you can trust.

Talk to it like an editor

Import the clips in ~/Footage/day03, sort interviews and B-roll into bins, and colour the circled takes green.

Build a 9:16 reel from these three shots, add subtitles from the audio, and render it for Instagram.

Conform this EDL against the media in ~/Rushes and deliver a ProRes master and an H.264 proxy.

Apply the show LUT to every shot of the timeline except the end card, and grab a still of the first shot.

Add a red marker at the start of every shot named "broll_" in Edit_03.

Duplicate the approved cut as "QC", export it as FCPXML and OTIO, and render 01:00:02:00 to 01:00:07:24.

How it works

flowchart LR

A["AI agent Claude, Cursor…"] -->|MCP call| V["Validate

• repair"] V --> C["Consent

deletes only"] C --> N["Snapshot destructive only"] N --> X["Call Resolve one thread"] X <-->|scripting API| D[("DaVinci Resolve")] X --> R["Read back → receipt"] R --> L["Audit log"] R -->|"verified: true / false"| A

1. Validate. The agent calls a domain tool such as timeline_write with {"op": {"action": ..., ...}}, and the parameters are checked against a typed schema. Almost-right parameters are repaired, and each repair is reported.
2. Consent and snapshot. Deletes stop at a plan until they are confirmed, and destructive edits take a snapshot first.
3. Call Resolve. The call runs on a single executor thread, the only place Resolve is ever called from.
4. Read back. The server reads the result back from Resolve and returns a receipt with verified. Long renders become jobs that the agent can wait on.

Tools

52 tools. Domain tools are named _read, _write and _delete, and take {"op": {"action": ..., ...}}; together they expose about 300 actions. Reads have no side effects, writes return a verified receipt, deletes ask for confirmation first.

• resolve_status - Connection state, Resolve version and edition, current project, timeline and page.
• describe_action - Compact parameter schemas of one or several actions.
• search_api - Search the Resolve 21.1 scripting API by name or description.
• batch_run - Run several tool calls in one call, server-side, with one confirmation for the batch.
• workflow_write - One-call jobs: conform_from_edl, deliver, build_vertical_reel, apply_look, title_overlay.
• recipe_list / recipe_run - List and run YAML or Python recipes; every step is validated, verified and audited.
• project_read / project_write / project_delete - Projects, folders, databases, settings and settings presets; create, load, save, archive, import, export.
• media_read / media_write / media_delete - Media pool and storage: import, bins, relink, proxies, metadata, markers, flags, multicam, mattes, audio sync.
• timeline_read / timeline_write / timeline_delete - Timelines, tracks, markers, playhead, compound and Fusion clips, import and export.
• item_read / item_write / item_delete - Timeline items: properties, speed, fades, takes, flags, colors, markers, transitions, stabilization.
• color_read / color_write / color_delete - Node graphs, CDL, LUTs, versions, color groups, DRX grades, DCTL.
• fusion_read / fusion_write / fusion_delete - Fusion comps and tools: add, connect, inputs, keyframes, expressions, Text+ titles, settings, fuses.
• gallery_read / gallery_write / gallery_delete - Still albums: grab, import, export, label.
• audio_read / audio_write - Loudness analysis, silence detection, normalization, voice isolation, Fairlight presets, audio mapping.
• render_read / render_write / render_delete - Formats, codecs, presets and render jobs; render a timeline or a range, Quick Export.
• interchange_read / interchange_write - EDL, FCPXML, OTIO, marker CSV and .cube LUT files, read and written without Resolve.
• ai_read / ai_write / ai_delete - Transcription, subtitles from audio, scene-cut detection, Smart Reframe, audio classification, IntelliSearch.
• vision_read - Export or screenshot frames and contact sheets so the agent can look at the picture.
• ui_read / ui_write / ui_delete - Pages, menus and keyboard shortcuts, for the few things the API can't do.
• app_read / app_write / app_delete - Resolve app info, layout presets, keyframe mode, quit.
• snapshot_list / snapshot_write - Safety copies of the timeline or project, taken automatically before destructive edits.
• job_status / job_wait / job_list / job_cancel - Long operations (renders, analyses) run as jobs.
• code_delete - run_lua and run_python inside Resolve, an escape hatch that is off by default and always asks for confirmation.

Install

Requirements </sum