How to record a demo with Claude using MCP

Recording a product demo is mostly chores: start the recorder, click through the flow, stop, find the moment that matters, add a zoom, cut the dead time, pick an export size. An AI assistant can do most of those chores for you if it has a way to control the recorder. That is what MCP is for, and it is what Dolly Pro adds: a local MCP server that lets Claude Desktop, Claude Code or Cursor drive Dolly's recording, editing and export.

This guide explains what MCP is, how to connect Dolly to each of those three clients, which tools the assistant gets, a few prompts that work, and what the assistant can and cannot do on your Mac.

What MCP is

The Model Context Protocol is "an open-source standard for connecting AI applications to external systems." Its own documentation compares it to a USB-C port: one standard plug, so any AI app that supports MCP can talk to any tool that exposes an MCP server. Anthropic introduced MCP in November 2024 as an open standard for secure, two-way connections between data sources and AI tools. It is now supported by Claude, ChatGPT, Cursor, VS Code and others, according to the MCP site.

Three terms are useful:

Client: the AI app you talk to (Claude Desktop, Claude Code, Cursor).
Server: a program that exposes tools. Dolly's server ships inside the app.
Tool: one action the model can call, with typed inputs, such as "start recording" or "export".

A local (stdio) server runs as a process on your computer, started by the client. The model never touches your screen directly; it asks the client to call a tool, the client asks the server, and the server does the work.

What you need

A Mac with Apple silicon and macOS 13 or later.
Dolly installed in /Applications (download).
Dolly Pro or Lifetime. Pro is €9.99 a month or €59 a year; Lifetime is €99 once (pricing). During launch month, every account gets Pro free until 30 November 2026. Without Pro, the read-only tools (status, sources, projects) still answer, and everything else replies that connecting your AI is part of Dolly Pro.
One MCP client: Claude Desktop, Claude Code or Cursor.
Screen Recording permission for Dolly in System Settings, which you grant the first time you record anyway.

ChatGPT is not supported yet. Its desktop app currently takes remote MCP servers, and Dolly's server is local by design. ChatGPT support is planned.

Connect Dolly to your AI client

The quick way

In Dolly, open the menu bar icon (or the File menu) and choose Connect your AI…. It has an Add to Claude Desktop button and an Add to Cursor button. Both ask you to confirm, merge Dolly into your existing config without touching your other servers, and keep a .bak copy of the old file. There is a copy button for the Claude Code command, and an Allow AI control switch (on by default) that you can turn off at any time. The manual steps below do the same thing.

Claude Desktop

Claude Desktop reads local MCP servers from a JSON file. The MCP documentation gives the location on macOS as ~/Library/Application Support/Claude/claude_desktop_config.json, and you can open it from the Claude menu bar item: Settings… → Developer → Edit Config.

Add Dolly under mcpServers:

{
  "mcpServers": {
    "dolly": {
      "command": "/Applications/Dolly.app/Contents/MacOS/Dolly",
      "args": ["/Applications/Dolly.app/Contents/Resources/mcp/dolly-mcp.mjs"],
      "env": { "ELECTRON_RUN_AS_NODE": "1" }
    }
  }
}

If the file already lists other servers, add the "dolly" entry next to them rather than replacing the whole file. Then quit Claude Desktop completely and open it again; the MCP docs note the app needs a restart to load new servers. If Dolly does not appear, the same page lists the logs at ~/Library/Logs/Claude.

The ELECTRON_RUN_AS_NODE line tells Dolly's own binary to run the bundled server script instead of opening the app window. You do not need a separate Node.js install.

Claude Code

Claude Code adds local servers with claude mcp add, using -- to separate Claude's options from the server command, as described in the Claude Code MCP docs:

claude mcp add dolly --scope user -e ELECTRON_RUN_AS_NODE=1 -- /Applications/Dolly.app/Contents/MacOS/Dolly /Applications/Dolly.app/Contents/Resources/mcp/dolly-mcp.mjs

--scope user makes Dolly available in every project, stored in ~/.claude.json. Leave it out to use the default local scope (this project only), or use --scope project to write it to a shared .mcp.json in the repository. Claude Code asks for approval before it uses project-scoped servers from .mcp.json.

Cursor

Cursor reads MCP servers from ~/.cursor/mcp.json (global) or .cursor/mcp.json in a project, per Cursor's docs. Use the same JSON as for Claude Desktop. Cursor's docs list "type": "stdio" as a field for local servers, so you can add it inside the "dolly" entry if Cursor asks for it.

The tools Dolly exposes

Once connected, the assistant sees these tools:

Tool	What it does
`dolly_status`	Reports whether Dolly is running or recording and which plan is active; starts Dolly if needed
`dolly_list_sources`	Lists the displays and windows that can be recorded
`dolly_start_recording`	Starts recording a display, a window (by id or app name) or an area
`dolly_stop_recording`	Stops and saves the take, or discards it
`dolly_pause_recording`	Pauses or resumes
`dolly_list_projects`	Lists your projects
`dolly_get_project`	Reads a project: clips, zooms, style, and every click (time and position) and typing range
`dolly_add_zoom`	Adds a zoom on a given click or time range
`dolly_edit`	Cut, trim, split, speed, mute, zoom changes, background, padding, corners, shadow, aspect ratio, cursor, rename, undo and redo
`dolly_auto_edit`	Cuts dead time (never through speech), speeds up typing and redoes zooms, using local heuristics; has a dry run
`dolly_export`	Exports an MP4 at 720p to 4K, 24/30/60 fps, in Auto, 16:9, 4:3, 1:1 or 9:16, and returns the file path (default `~/Movies/Dolly/Exports`)
`dolly_open_project`	Opens a project in Dolly's editor so you can review it
`dolly_record_demo`	The whole flow in two phases: start (with optional steps shown as an on-screen checklist that is not in the video), then finish, which stops, auto edits, exports and opens the result

You do not need to name tools in your prompts. Describe the video you want and the assistant picks the tools.

Record your first demo

Example: a Notes demo from Claude Desktop

Record a 30-second demo of creating a new note in Notes, then export it as a 1080p video.

A useful thing to understand: Dolly records and edits, but it does not click around your Mac. The steps inside the demo are carried out by whoever can do them. Claude starts dolly_record_demo with the steps, which appear as an on-screen checklist that is not recorded into the video. You do the steps (or Claude does, if your client has computer use turned on), then Claude finishes the demo: Dolly stops, auto edits, exports and hands back the path to the MP4.

Example: a terminal demo from Claude Code

Record my terminal while you run the tests, cut the waiting, export for Twitter (1:1).

This is where Claude Code shines, because it can do the steps itself: it starts a Dolly recording of the terminal window, runs your test command, stops the recording, uses auto edit to cut the waiting and typing, and exports a square MP4.

Example: polishing a recording you already made

Open my latest Dolly recording, cut the dead time, zoom in on every click and export it square for social.

This one needs no computer use at all. The assistant reads the project with dolly_get_project, which includes every click and typing range, runs auto edit, adjusts the zooms and exports a 1:1 MP4. You can then open the project in Dolly and adjust anything by hand, because every change is an ordinary zoom block or timeline section.

Tips for good results

Name the window. "Record the Safari window" is more reliable than "record my screen", and it keeps notifications and other apps out of the shot.
Give a target length and format. "About 30 seconds, 1080p, 16:9" saves a round of edits.
Say where the zoom should land. Auto zoom follows clicks, but if one moment matters most, say so.
Review in the editor before you post. Ask the assistant to open the project when it is done.

Safety: what the assistant can and cannot do

Giving an AI control of a screen recorder deserves a careful look. Here is how it works.

What it can do

Start, pause, resume and stop recordings of the displays, windows and areas Dolly can see. A recording started by an AI stops by itself after 10 minutes at most.
Read and change Dolly projects: zooms, cuts, speed, styling. Every change is undoable in the editor.
Export MP4 files to your Mac and tell the client where they are.

What it cannot do

Upload or publish anything on its own. The MCP server talks to the app over 127.0.0.1 with a private token. Nothing leaves your Mac through Dolly unless you ask for Dolly links. If you want the video posted somewhere else, you do that yourself.
Click, type or open apps through Dolly. None of Dolly's tools control other apps. Anything the assistant does on screen happens through other tools your client gives it, such as Claude Code's shell or computer use, and those are governed by that client's own permissions.
Change macOS permissions. Dolly needs Screen Recording permission once, and only you can grant it in System Settings. If it is missing, the assistant gets a clear message instead of a recording.

Approvals in your client

Dolly itself does not ask before each action. The one confirmation it shows is when it writes your Claude or Cursor config, and the Allow AI control switch turns the whole connection off. Per-action approval comes from your client. All three clients put you in the loop by default. The MCP documentation describes Claude Desktop asking for approval before running tools. Cursor's docs say it "asks for approval before using MCP tools by default". In Claude Code you can allow or deny tools with permission rules such as mcp__dolly__dolly_export for one tool or mcp__dolly for the whole server.

A sensible setup: allow the read-only tools (dolly_status, dolly_list_sources, dolly_list_projects, dolly_get_project) without prompts, and keep a prompt on anything that starts a recording.

What it records is what is on screen

The biggest real risk is not the AI, it is the content. A recording captures whatever is visible: a Slack message, an API key in a terminal, a customer's name in a dashboard. Before you start:

Record a single window rather than a whole display.
Close or hide anything you would not want in a public video.
Use test data and test accounts for demos.
Turn on Do Not Disturb so notifications stay out of the shot.

Review before you publish

Treat the exported MP4 like a pull request from a colleague: watch it all the way through before it goes anywhere. Check that the zooms land on the right thing, that nothing private slipped in, and that the cuts did not remove something important. Auto edit is a fast first draft, not a final review.

Where to go next

If you already use Claude Code or Cursor every day, this is the fastest way to produce release-note videos and README demos without leaving your workflow. Dolly Pro is €59 a year (or Lifetime, €99 once), with a 30-day refund window, and everything stays on your Mac. The docs cover recording permissions and export settings in more detail.