Editing Video with Natural Language: An AI Assistant + the DaVinci Resolve MCP

How I turned a raw 2-minute-43-second screen recording into a finished, captioned, chaptered YouTube cut, complete with an animated intro and a music bed, just by describing what I wanted in plain English and letting an AI assistant drive DaVinci Resolve through the Model Context Protocol (MCP).

Companion video: I walk through this whole exercise in this YouTube video, which is also where I got the idea.

---

The idea

DaVinci Resolve has a full scripting API. The DaVinci Resolve MCP server wraps that API in Model Context Protocol tools, so any MCP-capable AI assistant (Claude Code, Antigravity, or Codex) can operate Resolve on your behalf.

The result is an editing loop that looks like this:

You: “Tighten this recording, then add captions and chapter markers.”

Assistant: plans the cut, shows you the plan, executes it into a new timeline, generates aligned subtitles, drops in chapter markers, renders a few frames to check its own work, and hands back the files.

You stay the director; the assistant is the editor’s hands. And this isn’t a demo toy. Everything below is a real, finished edit.

What I made

Here’s the finished cut, edited entirely through the plain-English instructions below. This was deliberately a test video: the recording just narrates through MLflow’s 3.15 demo example, so the subject matter doesn’t really matter here. I picked an essentially random take on purpose, to judge the editing rather than the content. I even left a yawn in the audio, to see whether the pipeline would notice odd, out-of-place sounds in the voice.

I started with one continuous 2:43 screen recording: a narrated walkthrough of MLflow’s LLM-observability features (traces, LLM-as-a-judge, human review, evaluation runs, prompt registry, AI gateway). Every change below came from a single plain-English instruction:

Step	What I asked for	Result
Tighten	”cut the dead air”	44 silent gaps removed, 2:43 → 2:19
Caption	”add captions”	74 timed cues + a corrected .srt sidecar
Chapter	”add chapters”	7 YouTube-valid chapter markers
Brand	”make the intro Agentic Craft”	animated Fusion title over the open
Preview	”summarize the sections as an intro”	an agenda that types on, then clears
Bookend	”append my outro”	my existing outro dropped on the end
Score	”add background music”	a ducked music bed under the intro
Translate	”add captions in German, Dutch, French, Japanese”	4 more .srt sidecars, same timings

The final deliverable: a 1080p / 30 fps H.264 file, plus a caption SRT and a copy-paste chapter list, ready to upload.

The setup

You need three things:

1. DaVinci Resolve. Studio is the smoothest, because external scripting is a Studio feature, though the free edition is still reachable through the MCP’s in-app bridge, so it isn’t a hard blocker. I paid for Studio (see the cost note below).
2. The DaVinci Resolve MCP server, connected to your assistant. It’s open source on GitHub and actively gaining features, so expect the tool surface to keep growing past what I describe here.
3. An MCP client: Claude Code, Antigravity, Codex, or any assistant that speaks MCP. This is the part people overthink. The assistant is only the natural-language front end; the capabilities all live in the MCP server, so the workflow ports across assistants almost unchanged.

Two optional-but-recommended companions on the machine: ffmpeg/ffprobe (the MCP uses them for waveform analysis, and you’ll want them for audio work) and a Whisper backend such as whisper.cpp for local transcription.

What it costs, and a cheaper route (Google Vids)

This pipeline isn’t free, and it’s worth being upfront about that. DaVinci Resolve Studio is a one-time license (US$295 at the time of writing; perpetual, not a subscription), and I paid for it precisely because external scripting is a Studio-only feature. On top of that, driving Resolve with an AI assistant assumes a paid Claude plan (Pro or Max). Neither is huge on its own, but together they’re a barrier worth naming.

There’s a much cheaper on-ramp, though, and I used it: the raw recording itself was made in Google Vids, where I did my first round of cuts before Resolve ever opened. Vids transcribes the take, flags filler words and pauses (18 in this 2:43 recording), and offers one-click sound cleanup. I read straight down that transcript to decide which cutscenes to trim. For a talking-head or screencast, that alone gets you a clean first pass.

So if you don’t have a Claude Pro/Max plan, Google Vids is the route I’d reach for first. Its AI editing is bundled into the cheapest Google paid tier, well below a Resolve Studio license plus an assistant subscription. What it won’t give you is open-ended, natural-language control of the entire Resolve API: the animated Fusion intro, chapter markers, frame-accurate audio ducking, render presets. That’s the whole point of the MCP route. Different tools for different budgets; on this project I used both.

The workflow, step by step

1. “Tighten this recording”

For a single long take, dead-air removal is the highest-value first pass. The MCP’s edit engine offers two flavors:

• Silence-ripple: ffmpeg detects silent gaps on the waveform; no transcription needed. It even calibrates its own threshold from the clip’s dynamics (on this recording it settled at −48.5 dB, well below speech and above the room floor).
• Transcript-tighten: word-level, needs Whisper, and can also catch filler words and tight restarts.

Every edit follows a plan → review → execute contract. The plan is a dry run: it reported 44 lifts totaling ~24 s and listed the largest gaps, so I could confirm none of them were swallowing real content. Executing produced a brand-new variant timeline, and the original was never touched.

2. “Add captions”

Resolve’s native Create Subtitles from Audio analyzes the timeline directly, so the 74 cues it produced were aligned to the tightened cut, not the original. Its speech-to-text was also noticeably better than the auto-transcript I’d pasted in: it spelled “MLflow” correctly throughout. It still fumbled the jargon, though (“Jinja” became “ginger,” “groundedness” became “groundness,” “correctness” became “characters”), which leads straight to one of the gotchas below.

3. “Add chapter markers”

Because the captions gave me exact timings, the assistant could drop chapter markers at each section boundary and hand back a copy-paste list for the YouTube description. YouTube has rules here (first chapter at 0:00, at least three, at least 10 s apart), and the assistant folded a too-short section into its neighbor to stay valid.

4. “Make the intro Agentic Craft,” with an animated agenda

This is where it graduated from operating Resolve to building motion graphics. The assistant authored a Fusion composition node by node: a dark scrim, a Text+ title, an “IN THIS VIDEO” label, and a seven-line agenda that types on (a keyframed write-on) before the whole card fades out to reveal the walkthrough.

5. “Append my outro” and “add background music”

The outro was a one-liner: the assistant dropped my existing outro clip onto the end of the timeline. The music was subtler: a bed pulled from my own outro track, ducked under the narration and faded so it lifts the intro without fighting the voice. (The audio gotchas that made it work are in the learnings below.)

Every one of those steps was a plain-English request. The interesting part is everything that had to be right underneath, which is the real subject of the rest of this piece.

The learnings (the part worth keeping)

Non-destructive is the default, and it matters

The MCP auto-archives a timeline before any destructive operation and builds edits as variants. Across this project I generated a dozen archived versions without thinking about it, and the original take was always one click away. Direct an AI to cut your footage and this is the safety net you want. (Source media is never modified either: analysis writes to a separate location, and variants reference the existing media.)

Match the project frame rate before the first timeline

The source was 30 fps; the new project defaulted to 24. Resolve locks timeline frame rate once the first timeline exists, so this has to be set up front; otherwise every duration and every audio-sync calculation drifts. Tell your assistant the source spec early.

Never let the assistant hand-type a clip ID

Media items are referenced by long hex IDs. Always fetch them from a probe call; never transcribe one from memory or a screenshot. A single transposed pair of hex digits fails every downstream call in ways that look like engine bugs.

Verify by rendering real frames, not by trusting “success”

This is the big one. A tool call returning success: true means the call worked, not that the result is right. The discipline that paid off all session was simple: render actual frames (or the actual file) and look at them.

• The first version of the intro returned success on every graph call and then failed the render at frame 1. Reading the error (and the frame) caught it immediately.
• I confirmed the finished composite by pulling frames out of the rendered MP4 and inspecting the intro, a content shot, and the outro.
• I confirmed the music was actually in the mix by measuring the audio in the first 0.15 s (before any speech): the render read −40 dB where the silent source read −90 dB. That 50 dB gap is the music: proven, not assumed.

If you take one habit from this, take this one: make your assistant show you the frame.

A Fusion Merge with an empty background fails the render

The intro’s fade was a Merge whose foreground was the title stack, with nothing wired to its background. Every setup call succeeded; the render died on the first frame. The fix was to feed the underlying footage into that background input. Empty Merge inputs are a classic Fusion trap, and they don’t surface until render time.

You can’t edit subtitle text through the scripting API

Resolve will generate subtitles from audio, but the API won’t let you edit the text of a subtitle item in place (the obvious call silently returns false). So the right move for a screencast is not to fight it: deliver a corrected .srt sidecar and upload that to YouTube as toggleable CC. It never covers the UI, it’s trivially correctable, and it sidesteps the API limitation entirely. Burn-in is the wrong default for tutorials anyway.

One caption file, any language

That sidecar decision paid off again when I wanted the video in more languages. Because the captions are a plain SRT rather than burned-in text, adding translations is nearly free: I asked for German, Dutch, French, and Japanese, and the assistant produced four more SRT files that drop straight onto the same cut, timings untouched. There was one subtlety worth knowing. Resolve had chopped the English captions into 74 mid-sentence fragments, and translating fragments in isolation yields broken grammar, because word order differs across languages. So the assistant first reconstructed whole sentences from those fragments (carrying each sentence’s exact time span), then translated the sentences. In YouTube Studio you upload one file per language and the viewer picks from the CC menu; five languages, one render. Try that with burned-in captions and you’re rendering the video four more times.

Keep your edits in sync: overlay in place beats prepending

When I asked for an animated agenda “as an intro,” the tempting move is to prepend a card, which shoves every clip, chapter marker, and caption right by the intro’s length, and there’s no clean ripple-insert in the API to do that safely. The move that kept everything aligned was to overlay the intro on a track above the opening footage, timed to clear right as the narration starts describing the screen. Nothing downstream shifted; chapters and captions stayed valid. When you’re directing edits, favor changes that don’t renumber everything after them.

Bring your own music, and mind the quiet lead-in

There’s no music generation here. The assistant can’t invent a track, and it shouldn’t pull random audio off the web (licensing, and it can’t judge fit). I reused my own outro music. Two ffmpeg-flavored lessons:

• Duck it. The raw music sat at −15 dB (mastered loud). Under narration you want a bed around −25 to −30 dB, with fades. ffmpeg bakes that in cleanly (volume=…,afade=in,afade=out) so you don’t fight timeline audio keyframes.
• Watch the lead-in. My first attempt used the outro’s opening 8 s, whose first ~2 s are a quiet ramp, so the music was inaudible during the exact moment of the title reveal. Profiling the track in 2-second chunks found the energetic section, and using that fixed it. Put the music on its own audio track so it mixes over the voice instead of colliding with it.

Destructive actions gate on a confirmation token

Deleting a track, rippling, and similar operations return a confirm token and refuse to proceed until you call again with it. It’s a small thing that makes “let the AI drive” feel a lot less scary: irreversible steps have a speed bump.

Rendering: pin the preset, verify the file

Resolve’s scripting API can’t reliably read back the current render settings, so the safe pattern is to pin a named preset (“YouTube - 1080p”) when creating the render job rather than trust inherited settings. Then confirm the output with ffprobe (codecs, duration, and an audio-stream check) before calling it done.

Where each assistant fits

I ran this with Claude Code, but nothing about the workflow is Claude-specific. Antigravity and Codex are equally MCP clients; point any of them at the DaVinci Resolve MCP and the same tools are available. The differences you’ll feel are UX, not capability: how each surfaces tool calls, how it shows you images, how it manages long-running background work. The capability lives in the MCP server and in Resolve.

A few practical notes that generalize across all three:

• The assistant needs to read image files to do the render-a-frame-and-look verification. All three can.
• Long renders and transcription are best run as background tasks so the conversation isn’t blocked.
• Give the assistant the source spec and your brand assets (logo, outro, music) up front; those are the inputs it genuinely can’t derive.

What still needs a human

Natural-language editing is real, but it isn’t magic. The judgment calls stayed mine:

• Taste: pacing, which pauses are “dead air” versus deliberate beats, how aggressive the tighten should be.
• Retakes and meaning: silence detection removes silence; it can’t tell a fumbled sentence from a good one. That’s an editor’s pass over the transcript.
• Assets: no music generation, no inventing B-roll. You bring the pieces.
• Final sign-off: the assistant verifies its own work with frames and levels, but you’re the one who decides it’s good.

A reflection on opportunity cost

I’m an AI engineer, not a video editor, and definitely not a graphic designer. Before this, a two-minute tutorial like the one above sat in a frustrating gap: worth making, but not worth the days it would take me to learn Resolve’s Fusion page, keyframe an animated title, or hand-balance a music bed under narration. The opportunity cost was simply too high, so the video either didn’t get made or got made badly.

What changed isn’t that I got better at editing. It’s that the skill became addressable in a language I already speak. I described the cut I wanted, and the assistant translated it into the hundreds of precise Resolve API calls I’d never have written by hand. The craft is still real, and a professional editor would still run circles around this. But the floor moved: a passable, branded, captioned edit is now a conversation away, not a course away.

That’s the part I can’t stop turning over. If a non-editor can now edit and a non-designer can now design, how many skills, and maybe whole roles, that used to sit behind years of practice are about to become one MCP and a few sentences away? I don’t think this replaces the experts. I think it quietly hands the rest of us the parts of their craft we could never justify learning, and I suspect the list of things any one person can now do is only going to get longer.

Takeaway

The interesting shift isn’t “AI edits video.” It’s that the editing surface becomes a conversation, backed by a tool layer that is non-destructive by default and can check its own output. You describe intent; the assistant translates it into a couple hundred precise API calls, renders a frame to prove it worked, and leaves your original untouched.

Tighten, caption, chapter, title, score — each of those was a sentence. The craft that used to live in the mouse now lives in the instruction, plus a short list of gotchas worth knowing before you hand over the keys.

---

Built with DaVinci Resolve Studio 21.0.4 and the DaVinci Resolve MCP, driven by Claude Code on macOS (Apple Silicon), with ffmpeg and whisper.cpp for media analysis.

Idea and walkthrough: youtube.com/watch?v=oXKK7l3-DVc. MCP server: github.com/samuelgursky/davinci-resolve-mcp, open source and actively developed. Raw footage was recorded and first-cut in Google Vids.