Un editor de video impulsado por IA que permite a los agentes eliminar silencios, editar mediante transcripciones, añadir subtítulos y exportar proyectos a software de edición profesional.
También conocido como MakeMyClip/editor, editor, @makemyclip/editor
- Stars
- 11
- Herramientas
- —
- Descargas, 30 días
- —
- Última versión
- 0.5.1
- Último commit
- 13 nov 2026
- Licencia
- MIT
¿Qué es MakeMyClip Editor MCP?
MakeMyClip Editor es un MCP server. Un editor de video impulsado por IA que permite a los agentes eliminar silencios, editar mediante transcripciones, añadir subtítulos y exportar proyectos a software de edición profesional.
Resumen generado a partir del README del proyecto
Acerca del MCP server de MakeMyClip Editor
Editar video mediante conversaciones en lenguaje natural es lo que MakeMyClip Editor permite a desarrolladores y creadores que utilizan agentes de IA. Esta herramienta de código abierto te permite gestionar proyectos de video localmente en tu máquina usando FFmpeg y whisper.cpp para la transcripción. Funciona como un MCP server para clientes como Claude Desktop o Cursor, además de ser una skill de Claude Code y una interfaz de línea de comandos. Debido a que se ejecuta completamente en tu hardware, no requiere subidas a la nube, cuentas ni API keys.
Los usuarios pueden realizar tareas de edición complejas como eliminar silencios, cortar palabras específicas de una transcripción y borrar tomas repetidas. El servidor proporciona herramientas para añadir subtítulos incrustados o crear tarjetas de título. Una vez completadas las ediciones automáticas iniciales, puedes exportar los resultados como un mp4 o como archivos de proyecto profesionales para Final Cut Pro, DaVinci Resolve o Premiere Pro. Este puente entre la automatización impulsada por IA y la edición manual profesional garantiza que cada cambio se registre en una línea de tiempo no destructiva que admite operaciones de deshacer y rehacer.
Qué puedes hacer con él
- 1Limpiar grabaciones de tipo talking-headPide a un agente que elimine pausas, borre tomas repetidas y añada subtítulos a un archivo de video sin editar.
- 2Ensamblar demostraciones de productosCombina múltiples grabaciones de pantalla en un único video pulido con tarjetas de título y duraciones específicas.
- 3Verificar la calidad de la ediciónIdentifica momentos específicos donde un corte podría recortar accidentalmente una palabra hablada.
Escrito a partir del README del proyecto. Cada caso de uso se verifica con una cita del mismo.
Cómo instalar MakeMyClip Editor MCP
Formatos verificados el 10 nov 2026Añadir a CursorAñadir a GooseInstalar MakeMyClip Editor MCP en Claude Code
$ claude mcp add editor -- npx -y @makemyclip/editorInstalar MakeMyClip Editor MCP en Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Instalar MakeMyClip Editor MCP en VS Code
.vscode/mcp.json
{
"servers": {
"editor": {
"type": "stdio",
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Instalar MakeMyClip Editor MCP en VS Code CLI
$ code --add-mcp '{"name":"editor","type":"stdio","command":"npx","args":["-y","@makemyclip/editor"]}'Instalar MakeMyClip Editor MCP en Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Instalar MakeMyClip Editor MCP en Codex
$ codex mcp add editor -- npx -y @makemyclip/editorInstalar MakeMyClip Editor MCP en Codex config.toml
~/.codex/config.toml
[mcp_servers.editor] command = "npx" args = ["-y", "@makemyclip/editor"]
Instalar MakeMyClip Editor MCP en Gemini CLI
$ gemini mcp add -s user editor npx -- -y @makemyclip/editorInstalar MakeMyClip Editor MCP en Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"editor": {
"command": "npx",
"args": [
"-y",
"@makemyclip/editor"
]
}
}
}Configuración
MAKEMYCLIP_FFMPEG_PATHOptional: an FFmpeg to use instead of the one ffmpeg-static downloads.
MAKEMYCLIP_WHISPER_MODELOptional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions.
MAKEMYCLIP_WHISPER_PATHOptional: the whisper-cli binary, when it isn't on PATH.
MAKEMYCLIP_WORKSPACEFolder the editor may read and write; put your videos here. Defaults to a folder in the temp directory.
| Nombre | Descripción | Tipo |
|---|---|---|
| MAKEMYCLIP_FFMPEG_PATH | Optional: an FFmpeg to use instead of the one ffmpeg-static downloads. | |
| MAKEMYCLIP_WHISPER_MODEL | Optional: a whisper.cpp model file (e.g. ggml-base.en.bin) for transcripts and captions. | |
| MAKEMYCLIP_WHISPER_PATH | Optional: the whisper-cli binary, when it isn't on PATH. | |
| MAKEMYCLIP_WORKSPACE | Folder the editor may read and write; put your videos here. Defaults to a folder in the temp directory. |
Verificaciones automáticas
Ejecutado 12 nov 2026Informe completo →Pasó nuestras verificaciones automáticas. Esto no es una auditoría de seguridad: lee el código y dale al servidor el acceso más limitado que necesite. Cómo funcionan las verificaciones
- Repositorio de origen vinculado y accesibleAprobado
- Licencia de código abierto (OSI)Aprobado
- Commit o lanzamiento en el último añoAprobado
- El nombre del paquete no es similar a un paquete popularAprobado
- El endpoint remoto usa HTTPSNo verificado
- Las herramientas destructivas están etiquetadasNo verificado
- Sin instrucciones ocultas para el modeloAprobado
- No hay avisos críticos en el paquete ni en sus dependenciasAprobado
README
Ver en GitHubMakeMyClip Editor is a free, open-source (MIT) video editor that AI agents drive. You ask Claude to edit a recording; it calls the editor's tools, and FFmpeg and a local whisper.cpp do the work on your computer. It ships as a Claude Code skill, the clip CLI, an MCP server, and a browser timeline editor. No cloud upload, no account, no API key, no telemetry, no generative AI.
"Cut the repeated takes and the pauses out of talk.mp4, caption it, and give me a DaVinci Resolve project."
Claude transcribes the recording locally, cuts the earlier take of each repeated phrase and the silences, captions the speech, flags any cut that may clip a word, and writes
talk.fcpxml. Each edit is one undoable step on a timeline you can open in the browser and take over.
What it does
Version 0.4.0 turns a raw talking-head recording into a clean, captioned cut that opens in a pro editor:
| Feature | What it does | CLI |
|---|---|---|
| Remove silence | Cuts the pauses out of a recording, with a sensitivity control and a dry run | clip timeline silence |
| Local transcription | Word-level transcript with timeline times, from whisper.cpp on your machine | clip timeline transcribe |
| Edit by transcript | Cuts a range of words out of a clip | clip timeline cut-words |
| Remove repeated takes | Cuts the earlier take of each phrase said twice in a row | clip timeline remove-retakes |
| Captions | Burned-in captions timed to the words, as short phrases or one word at a time | clip timeline captions |
| Cut check | Flags cuts where a word may be clipped, with a contact sheet of the frames on each side | clip timeline check |
| Export to Final Cut Pro and DaVinci Resolve | FCPXML 1.10 project | clip timeline export --format fcpxml |
| Export to Premiere Pro | Final Cut Pro 7 XML project, captions as .srt files |
clip timeline export --format xmeml |
| Render | mp4 of the finished cut | clip timeline export |
All of it works from chat (the Claude Code skill or the MCP server), the CLI, and the browser UI; the cut check isn't in the UI yet. Every edit is one step on a non-destructive timeline that undo and redo walk through. Underneath sit 19 single-file FFmpeg tools for everything else: trim, split, concat, transitions, text and title cards, zoom/pan, overlay, speed, color, chroma key, stabilize, and render.
Install in 30 seconds
As a Claude Code skill (chat-driven, no global install):
npx skills add MakeMyClip/editor
Or install it as a Claude Code plugin from this repo's marketplace, inside Claude Code:
/plugin marketplace add MakeMyClip/editor
/plugin install makemyclip-editor@makemyclip
As a CLI (for scripts and CI):
npm i -g @makemyclip/editor
clip --help
As a browser UI (dark visual timeline editor):
clip ui # opens http://127.0.0.1:5573
As a Claude Desktop extension (one click, no Node or config file):
- Install FFmpeg:
brew install ffmpegon macOS,winget install Gyan.FFmpegon Windows. - Download
makemyclip-editor.mcpband double-click it, or drag it into Claude Desktop.
Put your videos in the extension's Media folder (by default Documents/MakeMyClip); the editor reads and writes only there. The extension doesn't include FFmpeg (see License): it finds the one Homebrew, MacPorts, winget, Scoop or Chocolatey installed, or you pick it in the extension's settings, along with the optional whisper model.
As an MCP server (drive it from Claude Desktop / Cursor / any MCP client — no API key, on your existing Claude):
// claude_desktop_config.json → "mcpServers"
{
"makemyclip-editor": {
"command": "npx",
"args": ["-y", "@makemyclip/editor", "mcp"],
"env": {
"MAKEMYCLIP_WORKSPACE": "/path/to/your/media",
"MAKEMYCLIP_WHISPER_MODEL": "/path/to/ggml-base.en.bin"
}
}
}
It is listed in the official MCP Registry as io.github.MakeMyClip/editor, so MCP clients that browse the registry can install it from there. The Claude Code skill auto-discovers triggers and shells out via npx -y on demand. The MCP server exposes the timeline tools (show / edit / check / transcribe / undo / redo / export) and a doctor setup check over stdio; media stays confined to MAKEMYCLIP_WORKSPACE, and MAKEMYCLIP_WHISPER_MODEL is only needed for transcription and captions. Everything runs locally and offline — no API key.
Optional: local transcription (for editing by transcript, removing retakes, and captions):
brew install whisper-cpp # macOS; other platforms: https://github.com/ggml-org/whisper.cpp
export MAKEMYCLIP_WHISPER_MODEL=/path/to/ggml-base.en.bin
Download a model such as ggml-base.en.bin from huggingface.co/ggerganov/whisper.cpp, and set MAKEMYCLIP_WHISPER_PATH if whisper-cli isn't on your PATH. The editor never downloads a model itself.
Check your setup:
npx -y @makemyclip/editor doctor # add --json for a machine-readable report
It checks Node, which FFmpeg runs and whether it can draw text and captions, the workspace, a caption font, and the optional whisper.cpp and model, and prints the fix for anything missing. In Claude Desktop or another MCP client, ask "is my setup OK?" and Claude runs the same check.
Quick start: clean up a talking-head recording
In Claude Code (with the skill) or Claude Desktop (with the MCP server), ask:
Clean up talk.mp4: remove the repeated takes and the pauses, add captions, check the cuts, then export an mp4 and a Final Cut Pro project.
The same steps from the CLI:
clip timeline new
clip timeline add-media talk.mp4 # prints the clip id, e.g. clip_ec2f047d
clip timeline transcribe clip_ec2f047d # each word with its time, plus repeated takes
clip timeline remove-retakes clip_ec2f047d # cut the earlier take of each repeated phrase
clip timeline silence clip_ec2f047d # cut the pauses
clip timeline captions # caption every transcribed clip
clip timeline check --sheet cuts.jpg # flag cuts that may clip a word
clip timeline export talk-clean.mp4 # render the cut
clip timeline export talk.fcpxml # or open it in Final Cut Pro / DaVinci Resolve
clip timeline export talk.xml # or in Premiere Pro
A cut splits the clip into pieces: the first keeps its id, and clip timeline show lists the rest, so run silence on each piece you want tightened (in chat, the agent does this for you). clip timeline undo reverses any step.
Another example: a product demo from screen recordings
Five screen recordings → one polished product demo. Type this into Claude Code (or Claude Desktop, via the MCP server):
Import these five recordings. Trim each to the most interesting 8–12 seconds. Add black title cards saying "Demo 1: Inbox", "Demo 2: Search", "Demo 3: Compose", "Demo 4: Calendar", "Demo 5: Reports" between them. Concat in order. Render to 1080p mp4.
The agent runs roughly ingest × 5 → trim × 5 → add_title_card × 5 → concat → render. The final mp4 lands in your workspace folder, every step is appended to session.json, and you can ⌘Z any of it.
Or skip the chat and do it from a script:
clip ingest demo1.mp4
clip trim demo1.mp4 5 20
clip add_title_card demo1-trim.mp4 "Demo 1: Inbox"
clip concat demo1-with-card.mp4 demo2.mp4 demo3.mp4
clip render concat-output.mp4 mp4 23 fast 1920
Same registry, same session log, same output.
All 19 tools
19 tools across 5 categories, four surfaces (Claude Code skill, CLI, browser UI, MCP server), one shared op log.
| Category | Tools |
|---|---|
| Cut & arrange | trim, split, concat, transition (12 kinds) |
| Text & captions | add_text, add_title_card, add_captions |
| Visual primitives | transform, adjust, zoom_pan (Ken Burns), overlay, speed |
| Composites & specialty | highlight_reel, silence_remove, chroma_key, stabilize |
| Output & I/O | ingest, preview, render, add_audio |
Plus four meta-ops not in the registry: snapshot, undo, inspect, delete.
The browser UI is a dark timeline editor: drag-drop import, a monitor (the composited frame at the playhead), an editable timeline (select a clip to trim / split / move / transition / remove, cut its silences, or cut words and retakes from its transcript), captions from transcripts, one-click export (an mp4, or a project for Final Cut Pro, DaVinci Resolve or Premiere Pro), timeline undo/redo, snapshot, and keyboard shortcuts.
Why it exists
Existing tools force a tradeoff that doesn't need to exist:
- iMovie / CapCut / DaVinci Resolve — mouse-and-timeline desktops. Can't be driven by an agent, scripted in CI, or version-controlled.
- Descript — closed-source, cloud-based, rewrites audio with generative AI you can't inspect.
- Runway / Pika / Luma — generate video from text. Useful for VFX, useless for assembling a 90-second demo from recordings you already have.
- Raw FFmpeg — deterministic and free, but the surface is hostile to LLMs: cryptic filter graphs, no session model, no undo, no tool catalog.
MakeMyClip Editor closes the gap: deterministic editing an agent can drive end to end (silence, transcript cuts, captions, export to pro editors) on a timeline it can inspect and a human can open and take over.
Feature matrix
| Feature | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Agent-driven (chat to edit) | ✅ | ❌ | ⚠️ | ❌ | ❌ |
| Open-source (MIT) | ✅ | ❌ | ❌ | ❌ | LGPL/GPL |
| Local-only (no cloud) | ✅ | ✅ | ❌ | ❌ | ✅ |
| Deterministic output (no AI generation) | ✅ | ✅ | ✅ | ❌ | ✅ |
| Free forever | ✅ | ✅ | freemium | paid | ✅ |
| Programmable CLI | ✅ | ❌ | ❌ | API | ✅ |
| Visual timeline UI | ✅ | ✅ | ✅ | ✅ | ❌ |
| Snapshot & undo | ✅ | ✅ | ✅ | ⚠️ | ❌ |
| Inspectable session log (JSON) | ✅ | ❌ | ❌ | ❌ | ❌ |
| Works as a Claude Code skill | ✅ | ❌ | ❌ | ❌ | manual |
| Stream-copy for lossless cuts | ✅ | ⚠️ | ⚠️ | ❌ | ✅ |
| Zero telemetry | ✅ | ❌ | ❌ | ❌ | ✅ |
Use-case matrix
| Job to be done | MakeMyClip Editor | iMovie / CapCut | Descript | Runway / Pika | Raw FFmpeg |
|---|---|---|---|---|---|
| Trim screen recordings to highlights | ✅ | ✅ | ✅ | ❌ | ✅ |
| Assemble a product demo from N clips + title cards | ✅ | ✅ | ⚠️ | ❌ | ⚠️ |
| Add script-provided timed captions | ✅ | ⚠️ | ✅ | ❌ | ⚠️ |
| Transcribe & edit video by its transcript | ✅ (local whisper.cpp) | ⚠️ | ✅ | ❌ | ❌ |
| Auto-cut silence from a recording | ✅ | ❌ | ✅ | ❌ | ⚠️ |
| Finish the cut in Final Cut Pro, Resolve or Premiere | ✅ | ⚠️ | ✅ | ❌ | ❌ |
| Chroma-key / green-screen compositing | ✅ | ⚠️ | ⚠️ | ⚠️ | ✅ |
| Generate b-roll / VFX shots from a prompt | ❌ | ❌ | ⚠️ | ✅ | ❌ |
| Multi-track audio mixing with effects | ❌ | ⚠️ | ✅ | ❌ | ⚠️ |
| Drive editing from an AI agent in natural language | ✅ | ❌ | ⚠️ | ⚠️ | ❌ |
| Run as a scriptable CI pipeline | ✅ | ❌ | ❌ | ⚠️ (API) | ✅ |
| Long-form (>30 min) with hundreds of clips | ⚠️ | ✅ | ✅ | ❌ | ✅ |
| Edit on Linux / headless / fully offline | ✅ | ❌ | ❌ | ❌ | ✅ |
Legend: ✅ great fit · ⚠️ works but not the best · ❌ doesn't fit.
Honest summary: MakeMyClip Editor is the right pick when you want deterministic, scriptable editing that an AI agent can drive end-to-end. Not the right pick for generative video (Runway), a hosted transcript editor with collaboration and AI voice features (Descript), or a heavy multi-track NLE (DaVinci, Premiere) — though it can hand its cut to one.
Claude Code → skill triggers → npx -y @makemyclip/editor <tool | timeline …>
│
Browser UI → /api/tools/:name · /api/timeline/verbs → registry + verb layer
│
Claude Desktop → clip mcp (MCP server) → timeline verbs
│
▼
Tool handlers (TypeScript)
│
▼
FFmpeg subprocess (args as array, no shell)
│
┌───────────────────────┴───────────────────────┐
▼ ▼
Composition document session.json
(non-destructive timeline, (append-only op log
op-log undo/redo) of every tool call)
Two layers of state, by design. The composition document is the source of truth for assembled edits: a non-destructive, multi-track timeline that clip timeline, the browser UI, and the agent (the Claude Code skill or the clip mcp server) all mutate through one op-aware path, with a coupled op log that powers undo/redo. session.json is an append-only op log of every tool invocation — { id, tool, args, result, timestamp } — written through the same appendOp() path by the single-file tools (clip trim, /api/tools/:name, …); it is the audit trail and recovery layer. Both layers are written through one serialized path, so any combination of human + agent edits stays consistent.
Build a composition end-to-end (CLI shown; the browser UI and the agent — Claude Code or MCP — drive the same document):
clip timeline new # start an empty composition
clip timeline add-media intro.mp4 # ingest + append a clip
clip timeline add-media demo.mp4
clip timeline transition <afterClipId> fade 0.5
clip timeline show # inspect tracks, clips, timings
clip timeline export final.mp4 # compile the document to a render
Every edit is undoable (clip timeline undo / redo, clip timeline log), and clip timeline at <sec> / frame <sec> give an agent read-only eyes on the document. Run clip timeline --help for the full subcommand list.
- Language: TypeScript (Node 24+) and React 19 (browser UI)
- Timeline schema: Zod (shared with the MakeMyClip.com web app)
- Subprocess: execa — args as an array, no shell injection
- FFmpeg: downloaded by
ffmpeg-staticwhen the npm package installs, with aMAKEMYCLIP_FFMPEG_PATHoverride and an installed FFmpeg as the fallback (the Claude Desktop extension always uses an installed one) - Transcription: optional, user-installed whisper.cpp, run as a subprocess
- MCP:
@modelcontextprotocol/sdk— theclip mcpserver (Claude Desktop / any MCP client) - UI: Hono server + Vite + React, plain CSS
Setup & installation
Do I need FFmpeg installed separately?
Not for the npm package, the CLI or the Claude Code skill: ffmpeg-static downloads an FFmpeg build for your platform when the package installs. The Claude Desktop extension is the exception: it doesn't include FFmpeg, so install it first (brew install ffmpeg or winget install Gyan.FFmpeg). For your own FFmpeg build (LGPL-only, custom codecs, hardware acceleration), set MAKEMYCLIP_FFMPEG_PATH to its path and the downloaded binary is ignored. clip doctor shows which FFmpeg runs.
What platforms does it run on?
macOS, Linux, and Windows — anywhere Node 24+ runs. The browser UI binds to 127.0.0.1 and needs no internet connection.
Can I use it without Claude Code?
Yes. The clip CLI and clip ui browser app are first-class surfaces, and clip mcp lets Claude Desktop (or any MCP client) drive it. Claude Code is one of several entry points — the editor is agnostic to which agent (or human) drives it.
Does it require an API key? No — nowhere. The CLI, the browser UI, the Claude Code skill, and the MCP server all run with no API key. Agent-driven editing uses whichever Claude you already run (Claude Code, or Claude Desktop via MCP); the editor itself never calls a language model.
Capabilities & limits
Is it production-ready? This release is feature-complete for local editing — a dark timeline editor (view, edit, preview, export), silence removal, transcript editing, captions, export to Final Cut Pro, DaVinci Resolve and Premiere Pro, 19 single-file tools, an MCP server, and 741 tests passing. The API surface is still pre-1.0 (tool schemas may change in minor ways before 1.0). Use it for real work; pin a version in CI.
What's the maximum video size or duration? No hardcoded limit. FFmpeg streams the file rather than loading it into memory, and the browser UI streams uploads to disk — multi-GB recordings work fine. This release isn't tuned for projects with hundreds of clips or runtime above 30 minutes; for those, drive the CLI directly.
Does it support 4K, HDR, or vertical (TikTok / Reels) formats?
4K and vertical aspect ratios work out of the box — render takes a maxWidth and preserves the source aspect ratio. HDR pass-through works; deliberate HDR-to-SDR tone-mapping isn't a named tool yet.
Privacy & data
Does it send my video files anywhere? No. The editor makes zero network calls — period. The agent runs in Claude Code or Claude Desktop, not inside the editor, so nothing leaves your machine.
Where does it store my files?
In a local workspace folder — $TMPDIR/makemyclip-editor by default; override with MAKEMYCLIP_WORKSPACE. The folder holds input files, output files, composition.json (the timeline), session.json (the op log), and snapshots/. You can version-control the whole folder.
Working with agents
Which AI model does it use? No language model — the agent is whatever you already run: Claude Code, or Claude Desktop / Cursor via the MCP server. They call the editor's tools; the editor executes them deterministically with FFmpeg. Transcription, if you set it up, runs your local whisper.cpp with a model file you download.
How does the agent know which tool to call?
Each tool and timeline verb ships with a Zod input schema (parameter docs inline via .describe()) and a one-line description. The Claude Code skill and the MCP server expose that catalog to the agent; it reads the descriptions, picks a tool, and fills in the arguments.
What if the agent makes a mistake?
Every edit appends to session.json and produces a new output file in the workspace; nothing is destructive. Press ⌘Z to pop the last op; click Snapshot before risky operations to save a named restore point; the entire workspace is a folder you can git init.
License & comparisons
Is it free?
Yes — MIT-licensed, free forever for local editing. No paid tier, no signup, no upsell in the editor. Paid AI-generation features (voice synthesis, music, stock footage) will live on MakeMyClip.com when they ship, behind a separate @makemyclip/generation package.
What's the license situation with FFmpeg?
The MakeMyClip Editor source code is MIT. FFmpeg is a separate program the editor runs as a subprocess, so its license covers the binary, not your application code. The build ffmpeg-static downloads is GPLv3 on Intel Macs, Windows and Linux. On Apple Silicon it is a build with nonfree parts that FFmpeg marks as not redistributable, so the Claude Desktop extension ships no FFmpeg at all. For LGPL-only or custom-build requirements (e.g. iOS App Store), set MAKEMYCLIP_FFMPEG_PATH to your own binary.
How is this different from running FFmpeg directly? FFmpeg is one binary with a complex CLI; MakeMyClip Editor is 19 named tools with typed inputs, a session log, snapshot/undo, a browser UI, and an agent-callable API. You're still running FFmpeg under the hood — but with a catalog any LLM can call, input validation that prevents bad commands, and a log you can inspect or version-control.
What's the relationship between this editor and the MakeMyClip.com website? The editor (this repo) is MIT-licensed, free, local, and limited to deterministic FFmpeg operations. MakeMyClip.com is the separate hosted product where paid AI generation features will live. The two share the timeline schema, so projects move between them.
How do I add my own editing tool?
Add a file in src/tools/<name>.ts exporting a Zod input schema and a handler, register it in src/ui/tool-registry.ts, and the tool becomes available in the CLI and the browser UI's tool picker. See AGENTS.md for conventions.
Questions people ask
Answers describe v0.4.0 (November 2026).
How do I edit a video with Claude Code?
Install the MakeMyClip Editor skill with npx skills add MakeMyClip/editor, then ask Claude Code in plain words, for example "cut the pauses out of talk.mp4 and add captions." The skill runs the clip CLI through npx, edits a timeline document in a local workspace folder, and renders with FFmpeg on your machine. Every edit can be undone.
Is there an iMovie or CapCut for Claude?
MakeMyClip Editor is built for that job: an open-source video editor that Claude drives through a Claude Code skill or an MCP server, with a browser timeline (clip ui) where you can watch and take over. It covers everyday edits (trim, join, transitions, titles, captions, silence removal) but isn't a full desktop editor; for finishing, it exports to Final Cut Pro, DaVinci Resolve or Premiere Pro.
Preguntas sobre MakeMyClip Editor MCP
¿Cómo agrego MakeMyClip Editor MCP a Claude Code?
Ejecuta claude mcp add editor -- npx -y @makemyclip/editor en tu terminal. Añade --scope user para que esté disponible en todos los proyectos.
¿Cómo agrego MakeMyClip Editor MCP a Cursor?
Abre ~/.cursor/mcp.json y añade el servidor en mcpServers, usando la configuración de Cursor que se muestra en la sección de instalación de arriba.
¿Esta herramienta requiere subir archivos a la nube o una API key?
No, todo se ejecuta localmente en tu máquina sin subidas a la nube, sin necesidad de cuenta ni de una API key.
¿Puedo exportar mis ediciones a software de edición de video profesional?
Sí, puedes exportar a Final Cut Pro, DaVinci Resolve o Premiere Pro.
¿Cómo funciona la transcripción?
Utiliza whisper.cpp para realizar transcripciones locales a nivel de palabra en tu propia máquina.
¿Hay alguna forma de deshacer una edición?
Sí, cada edición es un paso único que se puede deshacer en una línea de tiempo no destructiva.