Timeline Studio: a local-first browser AI video editor where agents and humans share one timeline

What Timeline Studio solves, and who actually needs it

Most browser video editors are forms wrapped around a server-side render. Timeline Studio takes the opposite position: the project, the timeline and the inference all live in the page. The README describes it as a local-first AI video editor that runs in the browser, combining a CapCut-style multi-track timeline with WebGPU AI music and repair, multilingual voiceovers, automatic captions, talking-avatar generation, and deterministic offline export.

The second audience is less common. The repository ships a skills/ directory, an MCP server script and an agent CLI, and the September 8, 2026 release added timeline markers that agents can read, add, update and delete through the Skill, CLI and MCP, with project inspection and semantic diff previews before changes are applied. So the product is aimed at two kinds of users at once: a creator who wants captions, voiceover and music without uploading footage, and a developer who wants an agent to plan chapters, mark musical beats or record revision notes on the same timeline the creator is looking at. The claim that both edit the same real timeline is the distinguishing feature. Plenty of tools let a model generate a clip; far fewer let a model place a marker at project time and leave the human's undo history intact.

How the shared command engine keeps agent edits and human edits from colliding

The architecture visible in the repository is a command layer sitting between three front ends and one timeline. The npm scripts expose the entry points: npm run agent starts scripts/timeline-command.mjs, and npm run mcp starts skills/edit-timeline-studio/mcp/server.mjs. The September 10, 2026 release note for WebMCP states that supported browsers can expose the open project to agents for structured inspection, preview seeking, and reviewed visual reorder and trim plans, and that the browser adapter reuses the shared command engine, checks for concurrent edits before applying, and preserves editor undo.

That last clause is the design decision worth noting. An agent does not mutate project state directly; it produces a plan, the plan is checked against the current project, and only then is it applied through the same engine the UI uses. Markers are stored at project time rather than wall-clock time and travel inside the portable .timeline project file, so an agent that marks a beat at 00:01:12 is describing a position in the edit, not a moment in a session. The trade-off is latency and ceremony: every agent action goes through inspection and diff preview, which is slower than letting a script write to a JSON file, and it means an agent cannot do anything the command engine has no verb for.

Installing Timeline Studio and making a first agent-driven edit

The README points at a hosted editor at video-editor.ai-creator.top, and the repository is a Vite app, so the local route is a clone plus the standard scripts. The package.json declares dev as vite --host 0.0.0.0 and build as vite build. Nothing in the repository states a required Node version, so check before assuming one.

npm install
npm run dev

That serves the editor on the Vite dev host with the --host 0.0.0.0 flag, which binds beyond localhost. The README notes that the root URL still opens directly into the editor, so there is no separate landing page to click through. For a production bundle, npm run build emits the static output and npm run preview serves it.

The agent side has its own setup step. The package.json defines skill:doctor as node skills/edit-timeline-studio/scripts/setup-host.mjs --check and skill:setup as the same script with --install. Run the check first.

npm run skill:doctor
npm run skill:setup

The check reports whether the host is ready for the skill; the install step wires it up. After that, npm run agent launches the CLI and npm run mcp launches the MCP server over stdio for a client that speaks the Model Context Protocol. The README does not document rollback behaviour for the setup script, so if you are installing into a shared machine, inspect setup-host.mjs before running --install. A reasonable first task is the one the release notes describe: ask the agent to add timeline markers for chapters and beats, read the semantic diff preview it returns, and only then accept it. If the diff looks wrong, you have lost nothing, because the change was never applied.

Where local-first inference stops being an advantage

The AI features are large models pulled into the browser. The README states that large models are lazy-loaded, revision-pinned and cached, and the AI capability list names Stable Audio 3 Small Q4 ONNX for music, Whisper small q8 ONNX for captions, MI-GAN for watermark removal, NanoVSR 644K for 4x restoration, JoyVASA plus LivePortrait for the digital human, and Kokoro 82M or Piper voices for speech. None of that runs on a machine without a usable GPU path. A laptop with integrated graphics and no WebGPU support will fall back or fail, and the README does not describe a CPU-only mode for these models.

The export story is the other boundary. The project advertises deterministic offline export, and the dependency list includes @ffmpeg/ffmpeg, @ffmpeg/core, mediabunny, @mediabunny/aac-encoder and @libav.js/variant-webcodecs. That is a browser-side encoding stack. It is a poor fit for a batch pipeline: if you need to render forty clips overnight on a headless server, a browser tab is the wrong execution environment, and nothing in the repository suggests a server-side renderer. The deep-synthesis notice is the third constraint, and it is not a technical one. The README states the tool is intended solely for technical research and learning, that users must use only facial images or videos of themselves or of people who have provided lawful authorization, and that users are solely responsible for legal liability. A talking-avatar feature with that notice attached is not something to wire into a public product without reading MODEL_LICENSES.md first.

Timeline Studio against a cloud AI editor and against a desktop NLE

The closest comparison is a cloud AI editor such as the hosted tools people search for under free AI video editor. The difference is where the bytes go. A cloud editor uploads your footage, runs the models on someone else's GPU, and returns a render; Timeline Studio keeps the project in the browser and runs the inference locally through WebGPU and WASM. The cost is that you supply the GPU and wait for model downloads on first use, and the benefit is that a personal video never leaves the machine. For a two-minute clip on a modern laptop that trade is easy. For a long 4K project it is not, because the encode happens in the same tab.

The second comparison is a desktop NLE. Those give you a mature project format, plugin ecosystems and reliable batch export, and they have no agent command layer. Timeline Studio's answer is the .timeline project file plus the Skill, CLI and MCP surface. If your workflow is one editor and one mouse, the agent layer is dead weight and a desktop NLE will be faster. If your workflow is a script that marks chapters or an agent that drafts a rough cut for review, that layer is the reason to pick this project at all.

Licence, model licences and what upgrades cost you

The repository is MIT licensed, and package.json carries "license": "MIT", so the application code is permissive and you can fork it. That does not cover the models. The repository root contains a separate MODEL_LICENSES.md, which is where the terms for Stable Audio, Whisper, MI-GAN, NanoVSR, JoyVASA, LivePortrait, Kokoro and the Piper voices are collected. Treat the MIT badge as covering the editor, not the weights. This is general information, not legal advice; if you plan to ship generated output commercially, read that file and the upstream model cards.

Upgrade cost is shaped by the release cadence. The project shipped v1.0.6 on 2026-08-26, v1.0.7 on 2026-09-08 and v1.0.8 on 2026-09-10, and the last push to the repository was on 2026-09-10. Releases arrive in clusters, and several of them change the agent surface: v1.0.7 added agent timeline markers, v1.0.8 added WebMCP. If you build against the MCP server or the CLI, pin a release and re-read the release notes before moving, because the command vocabulary is still expanding. The npm run check script (lint, typecheck, build) is the fastest way to find out whether a fork still builds after you pull.

Editorial conclusion

Adopt Timeline Studio if you want a browser editor whose timeline can be driven by a script or an agent, and you accept that large models are lazy-loaded into browser cache and that deep-synthesis output is your legal responsibility. Skip it if you need a cloud render farm, headless batch encoding, or a project format you can round-trip through desktop NLEs. Verify first that your browser exposes the WebGPU and WebCodecs paths the AI features and export depend on, and read MODEL_LICENSES.md before shipping anything generated with the bundled models.

Frequently asked questions

Official sources

1. License: MIT
2. MartinDelophy/ai-video-editor on GitHub
3. Project website
4. README
5. Releases