Model or dataset
ronak-create/FableCut avatar
ronak-create/FableCut

The most interesting decision in this browser video editor is that the project file is the interface

Zero-dependency browser video editor that AI agents can drive — JSON timeline, MCP + REST, live-reloading UI

797 stars106 forksJavaScriptMIT

At a glance

What is it?
Zero runtime dependencies, one Node command to start it, and a timeline that is a JSON document rather than something you can only reach through a user interface. That is what lets a person and an agent edit the same cut at the same time.
Who is it for?
Two things to know. The architecture bet is that a project file being JSON is sufficient to make a tool scriptable, and the readme makes the case explicitly: any process that can write JSON can edit video.
Can I use it commercially?
Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
Is it still maintained?
Yes. The repository received new commits within the last day.
What is it written in?
Mainly JavaScript, according to GitHub's language statistics.

Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.

From daily snapshots

Star history

  • ronak-create/FableCut797 ★ · +134
Star history
Repository2026-09-112026-11-15
ronak-create/FableCut663797

134 Stars in the last 65 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

The project file is the interface, and that is the whole argument

The positioning line is that most artificial-intelligence video tools hide the edit behind an interface. This one does the opposite: the project file is the interface.

That file describes media, clips, tracks, effects, keyframes and transitions. It is a JSON document. So any process that can write JSON can edit video.

Read that as a bar rather than a boast. Most tools that claim to be automatable expose an interface that wraps the operations a user interface can perform. This one says the state is a document, and a document does not need a wrapper.

The consequence is the second sentence in that section: a human and an agent can work on the same timeline at the same time, with the browser interface reloading in about a tenth of a second over a server-sent event.

That number is the load-bearing one. If the reload were two seconds, sharing a timeline with an agent would be unusable, because you would lose your place every time it wrote. At a tenth of a second the human interface is a live view of a document someone else is editing, which is the same relationship you have with a document two people are typing in.

It is worth being clear about the trade here, because it is the whole design. You give up an interface that enforces valid operations, and you get an interface that is anything capable of writing JSON. The safety comes from somewhere else, and we will get to where.

Zero dependencies, one command, and what that costs

The install story is two lines: no package manager dependencies, and one Node command to start the server.

That is a genuinely unusual constraint for a video editor. A non-linear editor needs codecs, and codecs are where dependencies live. So the first question is what happens to decoding and encoding, and the answer is that the browser already has them, through a web-standard hardware-accelerated codec interface. The repository names it in a file of its own for the audio processing work, and the release notes call out export through the same interface.

Using the browser's own codecs means the editor ships no ffmpeg binary, no native module and no platform-specific build. It also means export quality and export speed are bounded by your machine, which is a real limit for a long timeline on a modest laptop.

The runtime requirement is modest as well: an eighteen-line manifest with two scripts, a start command and a test command using the runtime's built-in test runner.

Two scripts and no dependencies is also a maintenance argument. There is no dependency tree to audit, no transitive packages to track, and nothing to break when something publishes a new major version. For a tool that reads and writes your video project, and that an autonomous process may be driving, that is a much better posture than the alternative.

The cost is that everything is in this repository. There is no editor engine to lean on, so every feature in the release notes is implemented here, which is visible in the file listing: separate files for audio effects, denoising, ducking, loudness measurement, edit operations, export jobs and encoding profiles.

Targeting and locking, and how the agent sees them

The two features I would read first in any editor built for automation are targeting and locking, and this one has both with unusually clear semantics.

Targeting: click a track's name to target it. The editing operations, meaning split, insert, ripple, close gap and jump to cut, touch only targeted tracks. There is also a separate visibility toggle that hides from preview and export but does not block edits, and the readme is explicit that a selected clip is edited wherever it happens to sit.

Locking: a padlock in the track header. Nothing on a locked track can be moved, trimmed, split or deleted, and a ripple leaves it in place while the other tracks shift around it. The use case given is the one that matters in practice: lock the music bed and re-cut the picture freely.

Now the part that matters for an agent. Locks are visible to the tool that applies edits. The patch operation refuses to edit a locked clip unless the operation explicitly says to force it.

That is the safety mechanism for the whole design, and it is a good one. Given a JSON interface, your protection against a runaway automated edit is not the interface. It is a rule the server enforces that the editor cannot talk its way around, with an explicit override rather than a silent bypass.

So the design resolves as follows. The JSON interface means anything can write the file. A server-side enforcement layer means certain writes are refused regardless of who makes them. And the force flag means a deliberate override is still possible, and is visible in whatever the agent produced.

The audio feature list reads like a mixing console manual

The most recent release is entirely about audio, and the feature list is specific enough to tell you what kind of tool this is: a mixer with a strip per track, faders, panning, mute, solo, meters, and a master with a live loudness readout.

One detail there is worth pulling out: preview and export run through the same mix. That single sentence eliminates the most common class of bug in browser editors, where what you hear during preview is not what gets rendered because the preview path and the export path have diverged. If they share a code path, they cannot disagree.

Clip-level audio has gain in decibels applied before volume and keyframes, a channel mode offering stereo, mono and the two individual sides plus a swap, and normalisation. The normalisation targets named broadcast and streaming standards: several loudness targets and a peak target. Linked stems share one gain, so a stereo pair stays balanced when you turn it up.

Volume is a draggable line with keyframes, fades with corner grips drawn with their real curve, and a crossfade that borrows spare media from both sides so nothing else has to move. That last one is the correct implementation of a crossfade and most editors get it wrong by inserting a gap.

Automatic ducking is the feature that shows the author has edited dialogue. Select the music, pick the dialogue track and an amount, and the music dips wherever someone speaks, ramping down before the line and back up after. The important property is stated immediately: it rides on top of the music's own volume, so re-running or clearing the duck never touches your levels.

Then effects: equalisation, filtering, compression, limiting, gating, delay, reverb, distortion, stereo width and pitch shift, chainable per clip, per track, per bus and on the master, with named presets ranging from clean voice to radio to telephone. And automation, where any effect setting can be keyed at the playhead the same way volume can.

None of this is new in video editing. What is unusual is that an agent can reach it, because the release notes name the specific interface each feature uses.

Markers, snapping, and the keyboard vocabulary

Editing features get described in terms of what they do for a video editor, and it is worth noticing how much of the vocabulary is inherited from physical editing rather than invented.

There are beat and cue markers, added by tapping a key during playback, named and coloured, draggable on the ruler, and navigable from a list. The snap targets are configurable from a menu, and the list includes clip edges, the playhead, markers, in and out points, keyframes and the frame grid. That last item matters: snapping to a frame grid is what makes an edit land where you meant.

There is multi-select on the timeline in the ways every editor implements them: a rubber band by dragging on empty track area, modifier-click to add and remove, select-all, escape to clear. Then group behaviour, which is the part that separates implementations: dragging any selected clip moves the whole group, delete removes all of them, and one key splits all of them at the playhead.

The readme is meticulous about which gestures do what, down to which modifier removes a keyframe rather than adding one and which one crossfades the cut beside the selection. That level of detail in a readme usually means the author wrote it after answering the same questions many times.

Direct manipulation on the preview is also there: click a clip or title on the preview to move, resize with corner handles, or rotate with a top handle. So an edit that needs visual judgement is done on the image, not on an abstract timeline.

And drop behaviour is handled rather than ignored: dropping a video with more audio channels than you have lanes adds the missing ones automatically, tells you how many it added, and puts each channel on its own lane as a linked stem.

Two interface servers, and why the repository root looks like that

There are two ways for a program to reach this editor. A protocol server file and a general server file, plus a configuration file for the protocol registry and a manifest for publishing it as a registry entry. The readme lists it in public directories of protocol servers, which is the modern equivalent of being listed in a package registry.

The repository root explains the rest. Beyond the usual governance files there are what look like feature modules sitting at the top level: audio effects, denoising, ducking, loudness measurement, edit operations, export jobs, encoding profiles, an import-by-URL script, path helpers, and two audio worklets plus a ruler worker.

Flat root instead of a nested structure is a deliberate choice. There is no dependency framework and no build step, so there is no reason for a directory tree, and a flat layout means every module is visible in one listing. If you want to know what this tool can do, you scroll the root.

The worklet files are the most interesting ones technically, because a worklet is a way to run code on an audio thread. Real-time meter worklets and filter worklets have to run somewhere that will not glitch when the main thread is busy, which is exactly what happens when you are decoding video and running an interface server on the same machine.

Then the agent-facing layer: a skills directory, an agent instruction file, a plugin manifest directory, and a file specifying which files not to package. Together those mean the tool is meant to be installed into an agent environment rather than only run by a person, and the packaging exclusion list suggests that has been an iterative process.

The release cadence matches the versioning: minor versions landing within days of each other, and the version numbers in the recent releases read like release notes rather than version strings, because that is what they are.

Editorial conclusion

Two things to know. The architecture bet is that a project file being JSON is sufficient to make a tool scriptable, and the readme makes the case explicitly: any process that can write JSON can edit video. That is a much lower bar than an interface, and it is why the editor is usable by an agent without any special support for one. The second is what this is not. It is a multi-track editor with effects, keyframes, loudness normalisation and ducking, which makes it a real tool, but it renders in a browser, so your export quality and your export speed are bounded by your machine rather than by the project.

Frequently asked questions

What is FableCut?

A multi-track video editor that runs entirely in your browser, with no runtime dependencies and one Node command to start it. What distinguishes it is that the project timeline is a JSON document rather than something you can only reach through a user interface, so an agent and a person can edit the same cut at once.

How does an AI agent edit video in it?

Through a protocol server and a REST interface, with operations named for what they do: patching the project, automatic ducking, setting effects. The timeline is a JSON document describing media, clips, tracks, effects, keyframes and transitions, so any process that can write JSON can express an edit.

How does it stop an agent from ruining a timeline?

With server-side enforcement rather than interface rules. Tracks and clips can be locked, and a lock refuses any edit unless the operation explicitly forces it. Track targeting restricts which tracks an operation touches, so you can re-cut picture while leaving a locked music bed in place.

Does preview match the export?

For audio, explicitly yes: preview and export run through the same mix, the same effects and the same loudness processing. That matters because the usual failure in a browser editor is a preview path and an export path that have drifted apart, so what you hear is not what renders.

What are the audio features?

A mixer with a strip per track plus a master and live loudness readout, per-clip gain and channel mode, normalisation to named broadcast loudness and peak targets, draggable volume lines with keyframes, fades and crossfades, automatic ducking of music under dialogue, a chainable set of effects with presets, and automation on effect settings.

Why does it have no dependencies?

Because it uses the browser's own codec and audio interfaces rather than shipping an encoder, which removes the dependency tree, the native builds and the supply chain. The trade is that export quality and speed are bounded by your machine, and every feature is implemented in this repository rather than inherited from an existing editor engine.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. ronak-create/FableCut on GitHub
Add this badge to your README

If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/ronak-create-fablecut.svg)](https://hysenlabs.com/projects/ronak-create-fablecut)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/ronak-create-fablecut.svg)](https://hysenlabs.com/projects/ronak-create-fablecut)

Was this useful?