Most coverage of the DaVinci Resolve 21.1 MCP server describes an AI that edits your timeline. It does not. The assistant writes a Python script against Resolve's API, and Resolve runs that script. Once you accept the script as the real product, the useful question changes from which model to use to how you store, parameterize, and share the scripts you keep.
What the DaVinci Resolve 21.1 MCP server actually does
The DaVinci Resolve 21.1 MCP integration lets an AI assistant write and run scripts against Resolve's API; it does not give the model direct control of your timeline. Blackmagic Design, the company behind DaVinci Resolve, added an MCP server to Resolve Studio 21.1. MCP, the Model Context Protocol, is an open standard for connecting AI assistants to external tools. Blackmagic's setup guide, How to set up AI Assistant and the MCP server in DaVinci Resolve Studio 21.1, covers the File > Setup AI Assistant route.
The distinction matters because it explains every limitation users hit. MrAlexTech demonstrates the behavior with a prompt to rotate every clip 180 degrees. The assistant inspects Resolve's documented scripting API, produces code, and Resolve executes that code against the open timeline. Nothing in the model sees your edit as pixels or clicks buttons; it emits an API call sequence.
Resolve has exposed a scripting API through its console for years, with Python and Lua bindings for timeline, media pool, render, and Fusion operations. The 21.1 release changes who writes the script, not what the script can reach. Longtime Resolve scripters can inspect the generated code in the same console they have always used.
That architecture produces one side effect the demo makes obvious. Because the assistant generates code fresh for each request, asking for the same operation on a later day can return a different implementation. It usually works, but it is not the same artifact twice.
Connecting Claude Code, or a local LLM to Resolve Studio
MCP client support determines which assistants can connect to the Resolve 21.1 MCP server. In the File menu, Setup AI Assistant detects locally installed clients such as Claude Desktop, Claude Code, and OpenAI's Codex CLI, then installs the server configuration for them. A locally hosted model running in an app such as Bionic needs the MCP server added manually by pointing it at the resolve-mcp executable path.
Registration is per client, so each assistant you use needs its own entry. That is convenient for switching models and annoying when a client updates and overwrites the config. If the connection stops working after a client upgrade, re-running Setup AI Assistant is the first thing to check.
The 21.1 integration is part of Resolve Studio, the paid edition. The free edition of DaVinci Resolve does not include the Studio-only AI features, and the MCP server sits in that same group. Confirm your license before planning a workflow around it.
A local model removes the cloud round trip but not the underlying behavior: it still writes a script each time you ask. The cost shifts from API fees to local compute and time. Neither approach stores the generated script for reuse.
Why AI-written scripts cost time and money on every run
Repeated AI scripting is expensive because the model regenerates the same logic instead of reusing it. MrAlexTech reports that a single request can take 5 to 15 minutes of generation, and that a more involved script, a photo slideshow builder with paper generators, Fusion drop shadows, and randomized rotation, took roughly 15 to 20 minutes to produce. The AI may also change the script's structure or output path between runs.
The cost is not only latency. Every prompt that hits a cloud assistant consumes tokens and, if you pay per token, money. A task you run twice a week for a year adds up. The same task saved as a script runs in the time it takes Resolve to execute the API calls, which is seconds for most timeline operations.
Reliability matters more than cost for anyone editing client work. A saved script behaves the same way every time, so you can test it once on a copy and trust it afterward. A freshly generated script has to be re-read before you run it, because the model may have added a step you did not ask for.
The practical rule: use the AI to write the script once, verify it, then treat the script as the deliverable. The prompt is scaffolding, not the tool.
DaVinci Resolve 21.1 MCP vs a saved script manager
The choice is between generating code per request and running stored code with parameters. Both reach the same Resolve API, but they differ in repeat cost, determinism, offline behavior, and shareability. The table compares the live MCP approach with the stored-script approach that MagicScript implements.
| Dimension | Live MCP prompting | Saved script with variables |
|---|---|---|
| Per-run cost | Model tokens and 5-15 min generation | Local execution, seconds |
| Determinism | New code each run, may vary | Same code path each run |
| Offline use | Needs the model reachable | Runs without network access |
| Customization | Rewrite the prompt | Edit parameter values |
| Sharing | Share the prompt | Share the script file |
The two are not mutually exclusive. MrAlexTech still uses the MCP server to write new scripts and pastes a guide document from MagicScript into a fresh assistant conversation so the model knows where to save files and how to define variables. The AI remains the authoring tool.
This is also why free local workflows become possible. Once the script exists on disk, no server needs to be up. The transcript's claim that scripts run completely offline holds only for that stage; the authoring stage still needs whatever model wrote the script, unless you write the code yourself.
How MagicScript stores, parameterizes, and shares Resolve scripts
MagicScript is a free Windows and Mac script manager that wraps Resolve scripts in an interface with adjustable values. The author is MrAlexTech, a DaVinci Resolve tutorial channel, and the tool's purpose is to hold scripts the AI already wrote. It installs as an app, then appears in Resolve under Workspace > Workflow Integrations > MagicScript. There is no Linux build at the time of the demonstration.
Each script exposes variables. A dissolve script asks for transition type and duration; the tool pulls the transition list from Resolve, so star wipes at 15 frames across every cut is a value change rather than a new prompt. A dynamic zoom script asks which track, whether to include photos, and how to handle easing. Multi-tab layouts appear when a script has many parameters.
Scripts save the project before running. Categories, such as a wedding list, group scripts for different jobs, and a favorites toggle pins the ones you use most. A compact 'mini' panel stays in a corner of the screen for one-double-click runs, which matters when you are working through a timeline.
A Stream Deck plugin ships with the installer. You can assign a script to a button and choose whether the button opens the parameter dialog or runs with the last used settings. The demo assigns a delete-all-transitions script and gets a confirmation prompt before it runs, which is the kind of guard a destructive operation needs.
Writing your own Resolve MCP script for MagicScript
Authoring a new MagicScript follows the same flow as any MCP request, with one addition: install the guide document first. MagicScript includes an AI guide button in its lower-right corner. It opens a Markdown file describing the expected save location and variable conventions. Pasting that file into a new assistant conversation gives the model the context it needs.
The workflow has four steps, and the order matters because the guide changes where the model writes files:
- Open MagicScript, click the AI guide button, and copy the Markdown contents.
- Start a fresh conversation with your MCP-connected assistant and paste the guide, then describe the script you want.
- Let the assistant write the script and run it against a test project to confirm the behavior.
- Save it in MagicScript, rename it, and set the variables you want exposed.
The dynamic zoom example shows why this is worth doing. Dynamic zoom is a Resolve effect that cannot be copied and pasted between clips, so a script is the only practical way to apply it across a track. The generated script asked for the target track, whether to include photos, and the easing and scale values. MrAlexTech notes he had not requested easing, and the model inferred it.
The transcript offers one caveat worth repeating. A script cannot make creative decisions for you. Cutting a long video into shorts requires deciding which sections deserve to be shorts, and that decision has to come from the editor. Marker-based scripts let you make those calls and still automate the mechanical work.
Example scripts and what they replace
The useful scripts in the demo are the boring, repeatable jobs. None of them requires judgment, and all of them would eat time if done by hand. Each one maps to a Resolve operation the scripting API already exposes.
A captions-to-SRT script generates subtitles for the current timeline and exports an unformatted SRT to a chosen path and filename. A thumbnail-candidates-from-markers script visits each marker, grabs a still, writes it to a folder, and reimports the images into the media pool for review. The filter-report script lists text and fonts in use, which helps before handing a project to another editor.
Other examples include assembling a bin in shooting order, deleting empty tracks, and adding dissolves at every cut. The photo-slideshow script creates a new timeline with a paper generator on track one, places every still from a bin on track two, adds cross dissolves at a set duration, applies drop shadows and dynamic zooms, and randomizes rotation angles through Fusion.
The 'shorts from ranged markers' script shows the boundary between scripted and creative work. The editor places ranged markers on sections chosen for shorts, names them, and runs the script. It duplicates the source, creates vertical timelines, applies grades, transitions, titles, and subtitles, and names each output. The selection stays human; the assembly is automated.
FAQ
- Does the DaVinci Resolve 21.1 MCP server let an AI edit my timeline directly? No. The assistant reads Resolve's scripting API, writes a script, and Resolve runs that script. It does not click through the interface or see your timeline as a live session. Every change lands as an API call sequence you could run yourself from the console.
- Is MagicScript free and which platforms does it support? MrAlexTech distributes MagicScript at no cost and it is available for Windows and Mac. There was no Linux build at the time of the demonstration. It integrates with Resolve through Workspace > Workflow Integrations and runs scripts locally, so it works without a network connection once the script exists.
- Do I still need an AI assistant if I use saved scripts? Only for authoring. Once a script is saved with its variables, you run it from MagicScript, the mini panel, or a Stream Deck button without contacting a model. A new script that does something you have not automated before is where the assistant earns its place.
- What can a MagicScript script not do? It cannot make creative choices. Selecting which sections of a long video become shorts, deciding a grade, or judging whether a take works are editor decisions. Scripts handle mechanical, repeatable operations, and marker-based scripts let you make the creative call first and automate the rest.
Where scripted automation fits in an editing workflow
The strongest use of the DaVinci Resolve 21.1 MCP server is generating one-off scripts for jobs you repeat often enough to notice. That is a narrower claim than 'AI edits your video', and it is the one the architecture supports. The model writes code; the code does the work; the work is repeatable.
The same pattern applies to any tedious timeline task, whether that is normalizing loudness before a YouTube upload, organizing a media pool by shooting order, or generating thumbnails from markers. Each becomes a small tool you own, with parameters you control and behavior you can predict.
The reminder in the demo is worth keeping. Automation should free the editor to make more creative decisions, not replace those decisions. A script that Stripe silence after you choose the cut points is a different thing from a model deciding what stays in the edit.
If you have a library of tutorials, interviews, or walkthroughs sitting in video form, the same idea applies to the knowledge inside them. Transcription turns a spoken explanation into a written draft you can edit, structure, and publish. Paste the video URL, generate the text, and shape it into an article with Skala Blog.
One more name for the credits: Gustavo dev doido, whose community work on video tooling is worth a look if you follow Brazilian editors online.
Fork this article
Start a new branch from the same video, shaped your way. You keep the credit; the original keeps the attribution.
A fork in another language is filed as a translation of this article, so the two pages point at each other. You can unlink it later from the editor.
0/240
You are creating
- Format
- For
- Language
- Source
- Your angle
You will be asked to sign in before it is generated.
Buy credits