Agent First Video Editor Library.

Agents edit video as code: a whole cut in one atomic batch, many agents on one timeline, every change undoable. Open-source Python, rendered anywhere.

00:00:00 / 00:15:00
01 / HOW IT WORKS

Three layers.
One clean path to the screen.

Agents write the edit. VisualKit checks, versions and stores it. A renderer turns the settled result into video, and you can swap that renderer without touching the project.

01

Agent, script or GUI

Describe the edit as code, in as big a batch as you like. People can drive the same engine from a GUI.

02

VisualKit engine

Validates every value, versions every run, and saves atomically. Bad edits never reach the project.

03

Renderer

DaVinci Resolve, FFmpeg, OpenTimelineIO, or any adapter you add. Renderers only read the snapshot.

Flow: an agent, script or GUI writes edit code; the VisualKit engine validates, versions and saves it; a renderer such as FFmpeg, DaVinci Resolve or OpenTimelineIO produces the video.
Every run leaves a record Failed edits write nothing Any renderer can be added
02 / WHAT YOU GET

The speed of code.
The safety of an editor.

BATCHED · CODED · PARALLEL
ONE LIGHT LIBRARY
BATCH EDITS

01Edit a whole video in one run.

One script, any number of edits, even the entire cut. The run is atomic: every change lands together, or none do.

See how a run is saved
01 clip.transform.scale = 1.08
02 clip.effects.add("grain")
03 clip.opacity = 0.92
⋮ 120 more edits in this run
123 changesvalidated together
atomic save
CODED CLIPS

02Code becomes a clip.

Write visuals or audio in HyperFrames, Remotion, Manim, OpenCV or any code-to-media framework. VisualKit validates and compiles them into clips you can trim, keyframe and effect like any other.

Read about coded clips
  • HyperFrames
  • Remotion
  • Manim
  • OpenCV
  • any code-to-media library
  • audio code too
LIGHTWEIGHT

03Run a whole crew at once.

DaVinci Resolve and Premiere Pro are too heavy to run two or three copies, even with MCP. VisualKit is a light library: run many agents at once, on separate projects or together on one timeline.

See claimed regions
03 / THREE DATA STATES

Make a mess in the Draft.
Only clean work reaches disk.

Your agent can make hundreds of edits, and plenty of mistakes, without touching the real project. Work moves through three states, and each one checks it again before it moves on.

  1. 01Draft dirtyMutable working copies of only the objects a run touched. Every assignment is checked on the spot.
  2. 02Session in memoryEach commit validates the changes and seals a snapshot. Sealed steps never change, and a GUI can walk them for undo and redo.
  3. 03Store on diskOne SQLite file with every revision, branch and run record. One atomic write per run, so disk is always the source of truth.
script · assignment check
Draftdirtylives for one run
clip_07 scale 1.08item_21 start 4.0sclip_09 effect grain
Sessionin memorylives for one process
step 1 · sealed copyclip_07item_21clip_09
Storeon diskpermanent
  • r42 visual_passHEAD
  • r41 b-roll
  • r40 grade
04 / HISTORY, BRANCHES, CHECKPOINTS

Try anything.
Take it back.

Every run becomes a revision. Name a safe point, fork a branch to experiment, undo a change or roll the whole project back, then merge what works. An agent can explore without fear because the previous cut is always one command away.

  • Append-onlyUndo, redo and rollback each add a new revision. Nothing is rewritten, so nothing is lost.
  • CheckpointsName any revision as a safe point. It costs nothing and can't be lost.
  • BranchesFork a line of experiments cheaply. Main never changes until you merge.
  • Three-way mergeMerges by object, and lists any conflict with both versions.
Try the buttons. It is a live model of the real commands.
mainr38roughrough-cutr39titlesr40gradeHEAD
$ visualkit logThree revisions on main. r38 is a named checkpoint.
05 / RENDERER INDEPENDENCE

Write the edit once.
Render it anywhere.

The project is backend-neutral, so the same script renders in FFmpeg, DaVinci Resolve or OpenTimelineIO. Need another renderer? Add an adapter once. Nothing in your project changes.

See how it fits together
VISUALKITone neutral project
settled branch → snapshot

FFmpeg Renders the settled snapshot to a file.

06 / SAFE PARALLEL WORK

Claim the time.
Not the whole timeline.

A claim reserves a half-open time range, [start, end), across every track. Only the owner can write there; everyone else reads the same immutable project snapshot. No dirty reads, no surprise edits.

01One exclusive windowThe region follows its owner, even as the surrounding edit moves.
02Conflict-aware by designClips and groups stay atomic unless a split is explicitly requested.
03Release with integrityValidate, commit atomically, then ripple for any duration change.
WHEN A CLAIM OVERLAPS

Expand connected clips or groups when allowed. Otherwise reject with a precise suggested range, or split only when requested.

episode_08.vkshared timeline
R1 · REQUESTED
title
lower-third
end-card
b-roll_01
b-roll_02
cutaway
cam_A
cam_B
reaction
room
foley
score
Mmaya-agentrequesting accessLOCAL CLOCKnot started Others: immutable snapshot
waiting for the grant
maya-agent asks for [12s, 24s) across every track.
07 / MORE FEATURES

And the rest
of the toolbox.

21 MORE THINGS
IN THE BOX
08 / QUESTIONS

Good questions.
Short answers.

Is VisualKit a video editor with a GUI?

VisualKit is a Python library and command line. Agents describe edits as code and the engine does the rest. It is GUI-ready by design, so a GUI can sit on the same engine and walk the same history.

What can it render with?

FFmpeg, DaVinci Resolve and OpenTimelineIO. Backends are adapters that read a snapshot of a settled branch, so adding another one never changes your project.

What happens if an edit has a mistake?

Nothing is written. A run saves once, atomically, and every error is reported together with its file, line and object. The failed run is still recorded, so the agent can learn from it.

Can several agents edit at the same time?

Yes. Each agent claims a range of the timeline and works in that region’s own local time. Others can read it but not write to it, and when a region grows or shrinks, later content ripples to stay in order.

Can I undo what an agent did?

Yes. History is append-only: revert a revision, restore a checkpoint, or branch to experiment and merge back. Nothing is ever rewritten.

Which frameworks can make coded clips?

HyperFrames, Remotion, Manim, OpenCV, or any library that turns code into visuals or audio. VisualKit validates the code and compiles it into a clip asset that behaves like any other clip.

Do agents ever see my API keys?

No. For third-party services such as AI video generators, VisualKit’s proxy carries the requests. Agents sign in to VisualKit, and short-lived work can use a temporary key that is revoked on its own.

What do I need to install it?

Python 3.10 or later. FFmpeg for probing and rendering. Then run uv add visualkit, or pip install visualkit.

A LIBRARY FOR WHAT’S NEXT

Let the agents
focus on the edit.

One install and one project file. Every edit an agent makes is checked, recorded, and easy to undo.

Read the docs
uv add visualkit
Python 3.10 or later. FFmpeg for probing and rendering.