Agents: this editor is scriptable from the page. Open the editor and run editorAgent.help() in the page's JavaScript, or read /AGENTS.md on this origin.
cutvid Start editing

A video editor an agent can drive

Everything the interface does goes through one command bus, and a script sends the same commands. window.editorAgent is documented, introspectable and reversible, and it edits a real timeline rather than a render template.

Start editingSee everything it does

Start here

Open the editor and run this in the page. It prints the reference and returns it, so it works as well for a model reading the result as for a person reading the console.

editorAgent.help()             // the whole reference
editorAgent.help('commands')   // commands, state, media, text, program, ui, frames, session, export
editorAgent.describe()         // every command, its parameters, its scope, as data

Why this is different from a render API

The usual way to make video from code is to describe a composition and have a server render it. That is a good way to produce a thousand similar clips and a poor way to edit one real one: there is no timeline to inspect, no footage to look at, and nothing to correct.

Here the agent drives the same editor a person uses. It can read the document, look at actual frames, find a spoken phrase, make a cut, watch what happened, and undo it. The interface is not a layer over the API: they are the same commands.

The cutvid editor: a bin of clips, the programme monitor on a forest scene, and a timeline with four clips, a title and a music track

What a batch looks like

// the document, as JSON
const doc = editorAgent.state()

// find where something was said; the answer is in timeline frames
const hits = editorAgent.findText('pricing')

// one batch is one transaction and one undo unit
editorAgent.dispatch([
  { name: 'clip.split', params: { seq: 'main', track: 0, f: hits[0].startF } },
  { name: 'segment.setTransition', params: { seq: 'main', track: 0, index: 1, kind: 'dip', durF: 12 } },
], { actor: 'agent:me' })

// look at the result the way a person would
await editorAgent.frames(assetHash, 100, 160)   // real frames on one canvas, captioned
editorAgent.program.snapshot()                  // what the monitor is showing

The parts that make it safe to hand over

A batch is a transaction
It applies whole or not at all, and counts as one undo.
Agent edits stay out of the human’s undo
A batch from an agent: actor does not land in the undo stack a person is using.
Sessions
Open one with named scopes, do the work, and revert the whole session in one move.
Checkpoints
Name a point and come back to it.
Dry runs
Ask what a batch would do before it does it.
Introspection
describe() returns every command with its parameters and scope, so the surface does not have to be guessed at.
Derived positions
A segment’s place is the sum of the durations before it. There is no position field to write wrongly.

What it can reach

  • The document and every sequence, asset and track, as JSON.
  • Import from a File or a URL; transcribe; read the text in the picture.
  • Every edit the timeline makes: insert, overwrite, razor, ripple, speed, reverse, loop, nests.
  • 34 transitions, 13 entrances, 10 loops, an effect stack, a LUT, chroma key, an anchor and keyframes.
  • A per-clip audio chain in one command, and loudness on the way out.
  • The programme monitor: seek, play, snapshot, and exact frames rendered for a vision model.
  • The activity dock as data, so a long job can be waited on rather than guessed at.
  • Export, resolving with the finished run.

Where the documentation is

Three places, all on this origin, all plain text: /AGENTS.md is the reference an agent should read first, /llms.txt is the short pointer, and editorAgent.help(topic) answers in the page itself. The document in the head of every page names the API too, and there is a note in the accessibility tree saying so, because a browsing agent reads that tree rather than the source.

The honest limits

  • Export is H.264 video and AAC audio in an MP4, or the sound alone as .m4a. No ProRes, no DNxHD, no H.265 out, no image sequences.
  • No team features: no cloud project, no review link, no comments, no shared library. A project lives in one browser, and moves as a file.
  • No stock library and nothing generative: no stock clips, no music bed, no AI b-roll, no generative fill.
  • No third-party plugins. No OpenFX, no VST, no motion-graphics templates from another app.
  • Colour is LUTs and the effect rail, not scopes, curves and secondaries. A .cube grades a clip; there is no vectorscope to grade against.
  • Built and checked in Chromium browsers, which is where WebCodecs is furthest along. Other browsers vary by codec and by version.
  • It runs in a tab, on one machine. A long 4K timeline is heavier here than in a native application on the same computer.

Questions

Is there an API key?
No. The API is a namespace on the page in the browser that has the editor open. There is no server and nothing to authenticate against.
Can it run headless?
It runs wherever a browser runs, including one driven by CDP or Playwright. It needs a real browser because the decoding and encoding are the browser’s.
Can an agent undo its own mess?
Yes, through a checkpoint or a session, which is why agent batches are kept out of the human’s undo stack.
Is there an MCP server?
Not yet. The surface is a documented JavaScript API on the page; anything that can evaluate JavaScript in a tab can drive it today.
Where do I read the full command list?
At /AGENTS.md on this origin, or by calling editorAgent.describe() in the page.

Open it and cut something.

No account, no install, nothing uploaded. The first edit takes as long as a page load.

Start editingSee everything it does