An AI agent editing a video has a memory problem. Ask it to tighten the intro, then come back an hour later and ask it to also fix the color on the second shot, and it often cannot tell you what it did the first time — it just renders a new file. You get an output you cannot open, diff, or partially undo. Every iteration is a fresh black box.
On August 28, 2026, Diffusion HQ (YC F24) open-sourced a video editor built to remove that problem. The pitch from founder Konstantin Paulus: "an open-source video editor that turns every edit into code." Or more bluntly — "code is the new database." Every trim, transition, overlay, and grade is emitted as JSX/TypeScript. The code is the source of truth; the timeline you see is a view of it. An agent works the edit the way a coding agent works a repo.
This connects directly to how explainx.ai has covered agent-driven video — video-use, ViMax, OpenMontage, and OpenCut — each of which answers "how does an agent touch video" differently.
TL;DR — what people are asking
| Question | Answer |
|---|---|
| What is it? | An open-source, browser-based video editor where every edit is JSX/TS code |
| Who made it? | Diffusion HQ / Konstantin Paulus, YC F24 |
| Announced | August 28, 2026 |
| Core claim | "Code is the new database" — the edit is a program an agent can read, diff, re-run |
| Does it generate video? | No — it edits existing footage; generation is out of scope |
| Is it free? | Yes, open source |
| Windows build? | Promised at 2,000 GitHub stars |
| Mobile build? | Promised at 15,000 GitHub stars |
| Production-ready? | No — early project, headline workflow unproven at scale |
| Source | github.com/diffusionstudio/editor |
Why a code source-of-truth beats an opaque render
The argument is not really about video. It is the same argument that made coding agents work.
A coding agent is effective because the artifact it edits — source code — is inspectable and incremental. It can read the current state, propose a diff, apply only that diff, and leave a commit explaining it. If the change is wrong, you revert one commit, not the whole project. A second agent can pick up where the first stopped because the state is fully legible.
Agent video editing has mostly lacked this. The common pattern is: prompt in, rendered file out. The rendered file carries no record of the decisions that produced it. There is no diff between "before the color fix" and "after." There is no way to re-run "the color fix" on a different clip. Each request regenerates everything, and context leaks out between turns.
Diffusion Studio's move is to make the intermediate representation — the thing the agent actually manipulates — a program:
// Illustrative: an edit expressed as composition code
<Composition>
<Clip src="interview.mp4" start={0} end={12.5} />
<Clip src="broll.mp4" start={12.5} end={18} />
<Text style={warmGrade}>Chapter One</Text>
</Composition>
Now the agent has the affordances it was missing. A change is a code diff. A revert is a git revert. "Apply the warm grade to every clip" is a function, not forty manual passes. And the edit is portable: you can hand the file to a person, to another agent, or to CI.
This is the same insight behind Fable 5 editing its own launch video with a transcript-plus-Remotion pipeline, and behind thin prompts, thick artifacts: the durable thing is the artifact the agent leaves behind, not the conversation that produced it.
The manual edit → reusable skill → batch apply pattern
The workflow Diffusion Studio leads with has three steps:
- Edit one video manually. Cut it, grade it, add lower-thirds — normal editing, in the UI.
- Turn that edit into a reusable skill. The captured code becomes a named, parameterized procedure.
- Apply it across all your videos. Run the skill over a batch and get consistent output.
If that shape sounds familiar, it is because it is the video version of an agent skill — a procedure you demonstrate once and then invoke by name, so the agent does not re-derive it every time. explainx.ai has argued that skills are how you stop paying the "figure it out from scratch" tax on every run; Diffusion Studio is applying that to editing conventions — your intro formula, your caption style, your standard export.
It also rhymes with what video-use packages as a shareable SKILL.md and what OpenMontage stages as a repeatable git-owned pipeline. The common thread across all three: the goal is not one good edit, it is a reusable editing capability you own.
Where it sits next to ViMax, OpenCut, and video-use
These tools are often lumped together as "AI video," but they solve different problems.
| Tool | What it does | Source of truth | Best when |
|---|---|---|---|
| Diffusion Studio | Edits footage; every edit is JSX/TS | The composition code | You want an agent to iterate on an edit without losing context |
| ViMax | Generates video from a script via AI models | A YAML config + model outputs | You have no footage and need it created |
| OpenCut | Conventional open-source NLE with plugins + MCP | The editor's project file | You want a normal editor a human drives, with an automation surface |
| video-use | LLM + ffmpeg edits raw footage from natural language | An edit-decision-list (EDL) JSON | You want conversational cuts on existing clips, no UI |
| OpenMontage | Multi-stage agentic production pipeline | A git repo of stages | You need a documentary-style pipeline you can re-run |
ViMax is upstream of the others — it makes footage that does not exist yet. OpenCut is the closest to a traditional editor and exposes automation through MCP rather than making the timeline itself a program. video-use already uses a structured intermediate representation (EDL JSON) that an agent generates and ffmpeg executes deterministically — arguably the same idea as Diffusion Studio, one level lower and without a visual editor attached. Diffusion Studio's differentiator is the round trip: you can edit in the UI and in code, and each reflects the other.
Honest caveats
JSX-as-timeline has ergonomic costs. Editors think in playheads, ripple deletes, and snapping. Expressing "nudge this clip 4 frames left and let everything downstream slide" is natural with a mouse and clumsy as a code edit. The round-trip UI is meant to bridge this, but the more an edit is authored by hand, the more the code abstraction is friction rather than leverage.
"Reusable skill" is a strong claim that is unproven. Capturing an edit as code is easy. Having that captured edit generalize — apply your intro treatment correctly to a video with different pacing, framing, and audio — is the hard part, and nothing about storing the edit as code guarantees it. This is the same gap agent skills hit: a skill that works on the example and breaks on the next input is a liability. Batch-apply is only as good as the parameterization.
It is an early project. No Windows build until 2,000 stars, no mobile until 15,000. Those are marketing milestones, not a roadmap you can plan around.
Does it actually reduce agent context loss? Partially, and conditionally. A legible code state genuinely helps an agent resume work and reason about prior changes — that part is real. But context loss also comes from the agent not knowing why an edit was made, and a JSX tree records the what, not the intent. You still need commit messages, comments, or a design doc for the reasoning. Code-as-source-of-truth is necessary, not sufficient.
"Not new" is fair. Scriptable timelines and programmatic compositing have existed for years in both paid and open-source tools, some more mature than this. What is new here is the framing — the edit as the primary agent artifact — and the open-source, agent-first packaging, not the underlying capability.
What people are arguing about
The skeptical replies to the announcement cluster into two:
- "Not new — better paid and OSS versions exist." True on capability. The bet is that agent-first design and an open codebase matter more than feature maturity right now.
- "Can't wait to git push --force my jump cuts." The joke lands because it is a real risk: if cuts are commits, they inherit code's failure modes. Force-pushes, merge conflicts on a timeline, a bad rebase that loses an afternoon's edits. Version control is only an asset with discipline around it — see loop engineering for what a disciplined agent loop actually requires.
What this changes for what you build
If you run agent-driven video at any volume, the takeaway is not "adopt Diffusion Studio today." It is: prefer tools whose intermediate state you can read. Whether that is Diffusion Studio's JSX, video-use's EDL JSON, or OpenMontage's git stages, a legible representation is what lets you debug a bad edit, resume across sessions, and turn a one-off into a reusable skill. A tool that only hands you a rendered file is a dead end for iterative agent work.
Related reading
- video-use: Claude Code as an AI video editor — conversational editing over an EDL JSON representation
- ViMax: agentic video generation guide — the upstream tool that creates footage before you edit it
- OpenCut: rewrite, plugins, headless MCP — editor-first open source with an automation surface
- OpenMontage: agentic video production with Claude Code — a git-owned, re-runnable production pipeline
- What are agent skills? Complete guide — the pattern behind "manual edit to reusable skill"
- Fable 5 edited its own launch video with Claude Code — transcript + Remotion, the same edit-as-code idea in production
- Thin prompts, thick artifacts — why the artifact the agent leaves behind matters more than the prompt
- Loop engineering with coding agents — what a disciplined agent loop needs to be reliable
Source: github.com/diffusionstudio/editor
Star-count milestones, build promises, and feature details reflect Diffusion Studio as of its August 28, 2026 announcement. The project is early and moving quickly — check the repository for current status.