AI video editors need a project file, not just an API

In the rapidly evolving landscape of AI-powered tools, one innovation stands out for its simplicity and power: treating the project file itself as the interface.

Last week, the open-source community witnessed the launch of FableCut, a browser-based video editor reminiscent of Adobe Premiere. However, its most compelling feature isn’t the editing capabilities—it’s the way it enables AI agents to interact with the timeline. Unlike traditional AI video tools that rely on APIs to manage edits, FableCut stores the entire timeline in a single JSON file called project.json. This file contains everything from media clips to transitions, allowing any tool that can write JSON to edit videos.

Whether it’s a Python script, a text editor, or an AI agent like Claude Code through MCP, the approach eliminates the need for custom API integrations. For example, a glowing kinetic caption is created not through an API call but by directly editing the JSON file. This design choice transforms how AI tools can collaborate with humans on creative projects, making the editing process more transparent and accessible.

The shift from API-driven to file-based editing

Most AI video editing tools operate by exposing functions like addClip() or applyFilter() through APIs. While this approach provides structure, it also introduces complexity, especially when human collaboration is involved. Developers must build entire layers to manage state, permissions, and real-time updates.

FableCut flips this model. Instead of hiding the timeline behind an API, the entire state lives in project.json. The editor UI reads from this file, the export process renders it, and any tool that can modify JSON can edit the video. This means an AI agent can edit a timeline, a developer can tweak it with a script, and a designer can review changes—all without needing to integrate with a proprietary API.

Consider a simple timeline entry:

{
  "id": "c_title",
  "kind": "text",
  "track": "V3",
  "start": 0,
  "duration": 2.2,
  "props": {
    "text": "HANDMADE",
    "font": "Bebas Neue",
    "glow": 45,
    "textAnim": "letter-pop"
  }
}

This represents a glowing, animated text clip. The AI or a developer doesn’t call a function to create it—instead, they write this JSON structure directly into the file. The change is immediate, visible, and editable.

Why SSE beats WebSockets for this use case

When FableCut launched, one of the top questions on Hacker News was about the choice of Server-Sent Events (SSE) over WebSockets. The answer lies in the simplicity of the data flow.

The server monitors project.json using fs.watch, debounces changes for 150 milliseconds, and then pushes a single string—change—to the browser. No payload, no complex data structures. The browser simply re-fetches the updated file and re-renders the timeline.

WebSockets, while powerful, are overkill here. The data only flows one way: from the filesystem or REST API into the browser. There’s no need for bidirectional communication, which means SSE’s lightweight approach is more efficient. A missed event doesn’t cause issues because the next fetch will always retrieve the latest state. This design keeps the system fast, predictable, and easy to debug.

How humans and AI share a timeline without conflicts

Collaboration between humans and AI agents on the same timeline requires a robust concurrency model. FableCut solves this with a simple but effective revision counter.

Every time the project.json file is modified, the revision number must increment. If an AI agent or a human makes a change but the revision number is lower than the current state, the server rejects the write with a 409 Conflict error. The agent then re-reads the file, applies its changes on top of the latest state, and writes again.

This approach eliminates the need for complex operational transforms or CRDTs. Since edits are coarse (whole document changes) and rare (human-speed modifications), last-writer-wins with a staleness check is sufficient. It’s a straightforward solution that keeps the timeline consistent without sacrificing performance.

Frame-accurate CSS animations for video export

One of the trickier aspects of video editing is handling animated SVG overlays, such as lower thirds or confetti effects. These animations rely on CSS @keyframes, but video compositors need to render them at exact moments in time—something that real-time animations can’t guarantee.

FableCut solves this by pausing every animation and driving time manually. The compositor sets the animation-delay to calc(var(--d, 0s) - t), where t is the clip’s local time. A negative delay means the animation starts in the past, effectively displaying the exact frame at the required time.

This method ensures that animations are deterministic, scrubbable, and identical in both preview and export. The only rule for SVG authors is to avoid hardcoding animation-delay and instead use the --d custom property for staggering animations. This approach bridges the gap between real-time web animations and frame-accurate video rendering.

Why FableCut isn’t a replacement for ffmpeg

Some critics on Hacker News pointed out that tools like ffmpeg can handle trims, concatenations, and batch transcodes far more efficiently. That’s absolutely true—for certain tasks.

The key difference is the creative workflow. ffmpeg is a write-only tool: an agent or script builds a filter graph, renders for minutes, and produces an output that can’t be easily tweaked. FableCut, on the other hand, treats the timeline as a living document. Edits are JSON diffs, updates appear in under 150 milliseconds, and the timeline remains fully editable.

FableCut isn’t designed to replace ffmpeg. Instead, it acts as the state and preview layer between the AI agent and ffmpeg. The export pipeline renders frames in the browser and pipes them to ffmpeg for final encoding. This hybrid approach combines the best of both worlds: real-time collaboration and high-performance rendering.

The future of AI-driven video editing

While FableCut is still evolving—headless export isn’t available yet and the compositor is Chromium-first—the project highlights a critical shift in how AI tools can interact with creative workflows. The file-as-interface model removes the need for complex APIs, making it easier for AI agents to collaborate with humans on projects like video editing.

It’s worth noting that while AI played a significant role in building parts of FableCut, including assistance with the README, the architectural decisions behind the project are what truly set it apart. The simplicity of the revision counter, the efficiency of SSE, and the frame-accurate animation system are all designed to work seamlessly with AI tools—not just replace human creativity.

For developers looking to experiment, FableCut is MIT-licensed, has zero external dependencies, and runs with a single command: node server.js. If you build something unconventional with it, the creator is eager to see what you come up with.