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.
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.
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.
Describe the edit as code, in as big a batch as you like. People can drive the same engine from a GUI.
Validates every value, versions every run, and saves atomically. Bad edits never reach the project.
DaVinci Resolve, FFmpeg, OpenTimelineIO, or any adapter you add. Renderers only read the snapshot.
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 savedWrite 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 clips01 intro = visualkit.clip(
02 source="hyperframes""remotion""manim""opencv",
03 duration=4,
04 )A coded visual, in a batch.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 regionsYour 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.
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.
$ visualkit logThree revisions on main. r38 is a named checkpoint.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 togetherFFmpeg Renders the settled snapshot to a file.
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.
Expand connected clips or groups when allowed. Otherwise reject with a precise suggested range, or split only when requested.
Times are exact fractions, so nothing drifts and saved projects round-trip without loss.
Source, clip and timeline time stay separate, so animation sticks to the right thing.
Keyframes tied to the source footage, held in place through every trim and split.
Ramp, freeze or reverse a clip by remapping clip time to source time.
Keyframes on the placed clip, applied after the speed curve.
Ordered effects on any clip: colour, blur, chroma key, audio EQ and more.
One clip applies its look to every clip below it, for picture or sound.
Node graphs for masks, keying and composites that a plain stack can’t express.
A whole mini-edit packaged as one reusable clip.
Repeat a group of clips with the same look and different content per copy.
Clips use asset IDs, so a moved file is relinked once and descriptions make footage searchable.
Agents use AI video services without ever handling the secret keys.
Run everything against the current state and print the change report, writing nothing.
Every run, failed ones included, is kept with its script and report.
Every command takes --format json, so agents read the same report you do.
A static check rejects imports outside the allowlist before a script runs.
Each agent gets its own working context: a branch, a claim and an expiry.
Split a claimed region among worker agents, so multi-agent systems can nest.
Merge and render only when no claims are open.
Plan each editing stage with markers, a storyboard and a director cut.
Export one JSON file per object, and import it back.
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.
FFmpeg, DaVinci Resolve and OpenTimelineIO. Backends are adapters that read a snapshot of a settled branch, so adding another one never changes your project.
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.
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.
Yes. History is append-only: revert a revision, restore a checkpoint, or branch to experiment and merge back. Nothing is ever rewritten.
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.
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.
Python 3.10 or later. FFmpeg for probing and rendering. Then run uv add visualkit, or pip install visualkit.
One install and one project file. Every edit an agent makes is checked, recorded, and easy to undo.
uv add visualkit