FableCut 推出可供 AI 智能體操作的 FableCut Studio

I've been building FableCut for the past few months, and one thing I've wanted to explore is what video editing looks like when an AI agent can work directly with the editor instead of just generating instructions for a human to follow.

The idea is straightforward: open a video editor, connect an AI agent, describe the edit you want, and let the agent make changes to your actual project.

That project is now FableCut Studio.

Studio: https://studio.fablecut.space/

GitHub: https://github.com/ronak-create/FableCut

Here's a quick demo of FableCut Studio in action:

What is FableCut?

FableCut is an open-source video editor designed to work with AI agents through the Model Context Protocol (MCP).

The project started as a local editor that agents could control through project.json and MCP. The first version shipped on July 6, 2026.

Since then, I've shipped 20 tagged versions, made 383 commits, and grown the project to 747 GitHub stars and 86 forks. It's available on npm as fablecut, is listed in the official MCP registry, and has been included in awesome-mcp-servers.

The original version required a local installation. Studio takes the same idea into the browser.

You open a link, load a project, connect an agent, and start editing.

No editor installation is required.

Why let an AI agent control a video editor?

Most AI video tools focus on generating a new video from a prompt. I wanted to explore something different: letting an agent work with an existing editing timeline.

Imagine giving an agent instructions like:

• Cut every occurrence of "you know" from this recording.
• Caption this reel in a highlight style.
• Remove the pauses from this take.
• Adjust the color grading of this shot.
• Export the final video in a vertical format.

These tasks involve more than generating a video. The agent needs to understand the project, make targeted changes, and preserve the existing work.

That's the direction I've been building toward with FableCut.

How Studio works

Studio runs at https://studio.fablecut.space/ and exposes 16 tools through remote MCP.

Different clients can connect to it, including Claude Code, claude.ai, Cursor, ChatGPT, OpenCode, and other compatible MCP clients.

The connection process depends on the client. For example, claude.ai supports a custom connector, while Claude Code can connect using a command.

Once connected, the agent can call tools to inspect and modify the project. Those changes appear live in the editor.

There's also an Agent panel that lists tool calls, and you can pause the agent or issue a new link when needed.

The important part is that the agent isn't simply returning a list of suggestions. It's interacting with the actual editing project.

What happens to the files?

In Chromium-based browsers such as Chrome, Edge, Brave, and Arc, Studio can work with a folder on your disk and save project.json there.

Firefox and Safari use browser storage for projects, with a download option for exporting the project as a ZIP.

Your video clips are not uploaded to Studio's server.

There is one important distinction: the remote MCP relay carries tool calls and their results, including project information and any frames the agent requests. It does not receive the media files themselves.

I think being clear about this boundary matters when building AI tools that work with local files.

What's new in v1.17?

The latest release adds transcription and text-based editing to Studio.

These features make it possible to perform common editing tasks using the words spoken in a video rather than manually searching through the timeline.

1. Transcription directly in the browser

Studio uses Whisper to transcribe audio in the browser.

The model is approximately 77 MB and downloads the first time transcription is used. After that initial download, transcription runs on the device.

In one desktop CPU test, 48 seconds of speech took 13 seconds to transcribe.

That is a useful result for a feature that doesn't require uploading the audio to a transcription service.

2. Editing videos through text

Once a transcript is available, you can interact with the words directly.

You can click a word to jump to its position, select words and delete them, or search for a phrase and cut every occurrence in one operation.

The cuts are grouped into a single undo step, making it easier to experiment without losing control of the edit.

For example, if a recording contains several repetitions of the same phrase, you can remove those repetitions without manually locating each one on the timeline.

3. Word-by-word captions

Studio can generate captions from the transcript and time them word by word.

The available styles include:

• Subtitle
• Karaoke
• Highlight, where the currently spoken word changes color
• Word pop

Caption layouts also adapt to the canvas dimensions, so vertical videos can use narrower lines than landscape videos.

SRT and VTT import and export are supported as well.

4. Silence removal

Studio can automatically remove pauses from a recording.

This is useful for talking-head videos, tutorials, interviews, and short-form content where long pauses can make the final video feel slow.

One limitation worth mentioning: Whisper generally drops filler words such as "um" and "uh". Silence removal and transcript-based editing serve different purposes, so filler removal is better handled through the silence-removal workflow rather than assuming every filler will appear in the transcript.

5. Agents can use these features too

The transcription and editing features aren't limited to manual use in the browser.

Agents can use tools such as fablecut_transcribe, fablecut_captions, and fablecut_silence.

That means a prompt like "caption this reel in highlight style" can become an actual editing operation instead of a tutorial explaining how to create captions.

This is where I think MCP becomes particularly useful: it gives an agent a structured way to interact with an existing application.

There's more than speech editing

The project has grown well beyond basic timeline operations.

Over the last several releases, I've added:

• Advanced editing: source monitoring, ripple and roll edits, track targeting, markers, and typed timecode.
• Audio tools: mixer buses, effect chains, automation, loudness normalization, auto-ducking, crossfades, and noise reduction.
• Color grading: waveform monitoring, RGB parade, vectorscopes, color wheels, curves, and HSL adjustments.
• Compositing: masks, track mattes, and motion tracking.
• Motion graphics: shape layers, parenting, motion paths, motion blur, text on a path, and animation presets.
• Media management: metadata search, offline relinking, proxies, delivery presets, and batch export.
• Project management: multiple sequences, version history, and faster exports through WebCodecs.

These features matter because an agent needs a real editing environment to work with. The more capable the editor becomes, the more useful its tools can be.

Agents can also inspect frames, measure color grades using scopes, and save project versions before substantial edits. The editor respects track locks rather than treating the entire timeline as freely editable.

Exporting without sending your video to a server

Studio encodes exports in the browser, supporting formats and codecs including H.264, HEVC, VP9, and AV1, with supported audio options.

WebCodecs has also helped make exports substantially faster. In v1.16, the project introduced an export path measured at roughly five times faster than the previous implementation.

For an editing application, performance matters just as much as the AI integration. An agent might make the right changes, but the workflow is still frustrating if exporting the result takes too long.

What if you prefer running everything locally?

Studio isn't the only way to use FableCut.

You can install the local version through npm:

npx -y fablecut

The local version exposes 21 MCP tools and supports additional machine-local workflows, including FFmpeg-dependent features.

This is a useful option if you prefer a local agent setup or need functionality that isn't available in the browser version.

Try it yourself

I've added a demo project containing skate clips, a music track, and an initial edit. You don't need to prepare your own footage just to see how the editor works.

1. Open FableCut Studio.
2. Load the demo project.
3. Connect a compatible AI agent.
4. Try asking it to caption the video or remove pauses.

You can also explore the source code on GitHub.

FableCut is released under the MIT license.

What's next?

I'm continuing to build FableCut around the idea that AI agents should be able to work inside real creative applications, with structured tools and visible results.

There's still plenty to improve, but the latest release brings the project closer to a workflow where an agent can help with the tedious parts of editing while the editor remains the place where the actual project lives.

If you try it, I'd genuinely like to hear what works, what breaks, and what you'd want an agent to be able to do next.