browser-use releases video-use: editing videos with a coding agent, the new frontier of coding agents

browser-use releases video-use: editing videos with a coding agent, the new frontier of coding agents

🔎 Video editing leaves the timeline for the terminal

There are GitHub repositories where nobody really writes an application — and yet everything happens in a terminal. video-use, published by the browser-use team, illustrates this shift: created on April 12, 2026, the project has accumulated 27,574 stars and 3,256 forks in a little over six months, and now ranks among the most prominent projects in the "video editing" category of the trending chart on gittrend.io.

The concept can be summed up in one sentence. You drop raw footage into a folder, you chat with your coding agent — Claude Code, Codex, or any agent with shell access — and you get back a final.mp4 that's been cut, color-graded, and subtitled.

Why now? Because three building blocks have matured at the same time. Coding agents can now execute commands reliably, ffmpeg remains the most complete scriptable editing engine on the market, and transcription APIs are accurate enough to serve as the basis for automatic cut decisions. video-use doesn't invent anything technically. It assembles — and that's precisely what makes the project interesting.

The essentials

• video-use is an MIT-licensed open source project from the browser-use team: 27,574 stars, 3,256 forks, repository created on April 12, 2026, with only 22 commits.
• The principle: your raw footage in a folder, a conversation with a coding agent, a final.mp4 as the output. No interface, no timeline to fiddle with using the mouse.
• The pipeline cuts out verbal tics ("umm", "uh", false starts) and dead air, color-grades segment by segment, applies 30 ms micro audio fades, burns in subtitles, and generates animated overlays via parallel sub-agents.
• The project's golden rule: the agent doesn't touch the edit until the strategy has been validated in natural language.
• The phenomenon goes beyond this repository: Timeline Studio, autoclip, Recordly, and OpenCut are sketching out an open-source wave where editing becomes an agentic task, not an interface.

Recommended tools

video-use is not video editing software, it's a skill for your agent

video-use is an open source repository under the MIT license that turns any coding agent with shell access into a fully operational video editor. It's not an app, not a plugin, not an interface: it's a method that your agent executes.

The team behind the project is no stranger. browser-use made its name with its browser automation library for agents, one of the most widely used projects in the agentic ecosystem. With video-use, the same philosophy applies to a new domain: give the agent standard tools, keep the human in natural language.

The repository's numbers tell an unusual story. 27,574 stars and 3,256 forks in six months, for only 22 commits. That ratio is the most interesting signal in this entire story.

The detail that says it all: 22 commits

Twenty-two commits is the volume of a weekend project, not an application. That's not a flaw, it's the design. video-use doesn't ship intelligence, it ships a procedure.

The heart of the project fits in a skill file that describes how the agent should proceed, along with a few utility scripts. The intelligence, meanwhile, comes from the model driving the whole thing — and that model is your choice. For twenty years, a video editor was a piece of software with thousands of commits. Here, the "editor" is a procedure that any compatible agent can follow.

Under the hood: six scripts, zero magic

The pipeline relies on a chain of Python scripts that wrap around ffmpeg and a transcription service, with strictly defined cutting logic. Nothing esoteric, but remarkable discipline.

Transcription goes through Scribe, the ElevenLabs service — an API key is mandatory. The transcribe.py and transcribe_batch.py scripts, which parallelize across 4 workers, convert the audio into timestamped text, and pack_transcripts.py prepares it all for the agent.

Then comes the most important decision: where to cut. The project's SKILL.md file is explicit — cut candidates come from speech boundaries and silences of at least 0.5 seconds. From this map, the agent eliminates filler words, false starts, and dead air.

Rendering follows a non-negotiable order in render.py: segment extraction, concatenation, overlays, then subtitles last — logical, since they need to sit on top of everything else. Each cut is protected by a 30 ms audio micro-fade, the kind of detail that prevents audible clicks. Color grading, handled by grade.py, applies customizable ffmpeg filter chains, segment by segment.

The timeline the agent actually "sees"

The cleverest script is called timeline_view.py. It generates a PNG combining a filmstrip of thumbnails and the audio waveform.

In other words, the agent doesn't work blindly from text: it has a visual representation of the timeline to base its decisions on. That's what separates a gadget from a tool.

Animations edited in parallel

For animated overlays, video-use doesn't go in for minimalism: each animation is generated by a dedicated sub-agent, via HyperFrames, Remotion, Manim, or PIL. The SKILL.md makes it mandatory — never sequential, always parallel, one sub-agent per animation.

The result: the total time for an edit with several animations equals the time of the slowest one, not the sum of all of them. For anyone who has ever waited for an export at 2 a.m., the difference speaks for itself.

Two final details deserve attention. First, self-evaluation: the agent checks the render at every cut boundary, which cuts down on back-and-forth. Second, memory: each session persists its decisions in a project.md file, and all outputs land in an edit/ subfolder, keeping the project folder clean.

The workflow that changes everything: never edit before validation

The most interesting rule of the project can be summed up in a single sentence: the agent doesn't touch the edit until the strategy has been validated in natural language.

The enforced workflow comes down to five steps: question, confirm the strategy, execute, iterate, persist. Concretely, the agent starts by asking you questions. What audience? What pace? Should hesitations be kept in for authenticity? You answer, it proposes an editing strategy, and it only executes after your explicit green light.

This contract may seem constraining. It is in fact what makes agentic editing viable. In a classic interface, a bad decision costs a Ctrl+Z. With an agent, it costs minutes of rendering and tokens. Locking in intent before execution isn't bureaucracy: it's what makes the process economically sustainable.

Persistence completes the picture. Since decisions are written in plain text in project.md, an edit is no longer a frozen state locked inside a proprietary file: it's a recipe — readable again, modifiable, re-executable. This is what fundamentally sets video-use apart from a mere CapCut template.

The open-source wave of agentic video editing

video-use is not an isolated case, but the most visible symptom of a wave that is filling the "video editing" category of GitHub rankings.

The second project to watch is called Timeline Studio (MartinDelophy/ai-video-editor). Created in July 2026, it shows 881 stars, 113 forks and 206 commits. Its positioning: a local-first AI video editor that runs in the browser, as an open-source CapCut-style alternative.

The feature list is impressive for a project just a few months old: multi-track timeline, AI-generated music via WebGPU, local video repair with MI-GAN, 4x restoration with NanoVSR 644K, in-browser vocal separation, captions, multi-language voiceover, talking avatars and deterministic offline export. All without sending your raw footage to a third-party server.

The detail that interests us here: Timeline Studio ships with an AI Video Editing Skill compatible with Codex, Claude Code, Copilot and Gemini CLI. The two worlds — graphical interfaces and agents — are starting to converge.

Around these two, the video editing category on gittrend.io brings together an entire generation of projects: autoclip for automatic highlight clipping, Recordly for no-edit video demos, or OpenCut, another open-source alternative to CapCut. We follow this wave closely in our selection of AI tools for video editing and AI tools for YouTube, because it is this wave that is reshaping the creator's workstation.

Why video editing is becoming an agentic task (and not an interface)

Because text has become the best interface for expressing an editing intent, and coding agents have become the best executors of that intent. Let's unpack the argument.

First point: ffmpeg has been scriptable for over twenty years. What was missing was not the technical ability to edit from the command line, but the intelligent driver capable of deciding what to do. That piece now exists: agentic leaderboards place GPT-5.5 (98.2), Gemini 3 Pro Deep Think (95.4), and Claude Opus 4.7 Adaptive (94.3) at the top of the rankings.

Second point: the coding agent war is spilling beyond code. xAI launched Grok Build, its first CLI coding agent, OpenCode has gathered 8 million developers and 172,000 GitHub stars, and Anthropic is turning Claude Code into a full-fledged platform. All these players are looking for territory beyond code. Editing is a natural one: files, shell, iterations, a verifiable render.

Third point, the most underestimated: reproducibility. An edit described in natural language and recorded in project.md is a recipe. Next week, your new raw footage will go through the same recipe, with the same color grading settings and the same subtitle style. An edit made with a mouse in traditional software is nothing of the sort — it's a one-off artifact, impossible to replay.

Fourth point: the economics. For a creator publishing three videos a week, logging the raw footage — spotting silences, cutting out hesitations, placing subtitles — represents hours of low-creative-value work. That's exactly the kind of task you delegate to an agent, while keeping control over the decisions that define the style.

The choice of model matters, of course. Frontier models dominate complex scenarios, but open-source is progressing fast: Kimi K2.7-Code, the 1-trillion-parameter coding model cuts reasoning tokens by 30%, and self-hosted models like Kimi K2.6 or GLM-5 make it possible to drive this kind of pipeline without depending on a closed API. Our roundups of the best autonomous AI agents and the best AI tools for code detail these options.

Getting started with video-use: four prerequisites, ten minutes

You'll need ffmpeg, Python, an ElevenLabs API key, and a CLI agent with shell access. Nothing else — no GPU, no special subscription.

git clone https://github.com/browser-use/video-use
cd video-use
ffmpeg -version                        # check the installation
export ELEVENLABS_API_KEY="your-key"   # required for Scribe transcription

Then, the ritual is simple. Drop your raw footage into the project's video folder, open your agent in that folder, and describe the outcome you want in one or two sentences: target duration, tone, subtitles or no subtitles.

The agent will then do what the project requires: ask you questions. Take the time to answer them — that's where the quality of the result is decided. Once the strategy is validated, the pipeline runs and you get final.mp4, with all the intermediate files neatly stored in the edit/ subfolder.

Two practical tips. For a first test, pick a five-minute talking-head recording: that's the use case the pipeline covers best. And if you want to run renders back-to-back without tying up your machine, a standard VPS will do — video-use doesn't need a GPU, and ffmpeg is a monster of CPU efficiency. A server for a few euros at Hostinger will handle this kind of load without breaking a sweat.

❌ Common Mistakes

Mistake 1: Letting the agent edit without validating the strategy

What goes wrong: skipping the validation step to "save time" produces off-target renders, and you pay for the full render before discovering the problem.

The solution: answer the agent's questions, validate the strategy in natural language, then let it run. Five minutes of dialogue saves an hour of wasted rendering.

Mistake 2: Ignoring the ffmpeg and ElevenLabs prerequisites

What goes wrong: video-use bundles neither ffmpeg nor a transcription engine. Without ffmpeg installed or an ElevenLabs API key for Scribe, the pipeline stalls at the very first step.

The solution: check both before your first session. ffmpeg is free on every system, and ElevenLabs offers a free tier for testing.

Mistake 3: Expecting an Avid in the terminal

What goes wrong: video-use excels at footage review, cleanup, subtitles, and overlays. It will not replace complex narrative editing with dozens of tracks and color grading negotiated shot by shot.

The solution: combine the two approaches. Let the agent produce a first clean, reproducible cut, then refine it in an editor — or in a project like Timeline Studio, which brings both worlds together.

Mistake 4: Preventing sub-agents from working in parallel

What goes wrong: chaining animations one by one multiplies production time by the number of animations. The SKILL.md is explicit: never sequential, one sub-agent per animation.

The solution: let the skill orchestrate. The total time for a multi-animation edit equals the time of the slowest sub-agent, not the sum of them all.

❓ Frequently Asked Questions

Is video-use really free?

Yes. The repository is MIT-licensed, with no restrictions on commercial use. The real costs lie elsewhere: the tokens consumed by the driving agent and the ElevenLabs subscription for transcription via Scribe. On short rushes, the bill stays marginal. With bulk processing, it becomes the biggest expense item.

Which coding agents are compatible?

According to the repository, any agent with shell access: Claude Code, Codex, Hermes, or OpenCode, among others. This is a direct consequence of the project's design — since video-use is a method more than a piece of software, any agent capable of running Python scripts and ffmpeg can follow it.

Do my videos leave my machine?

Editing stays local: ffmpeg processes your files on your machine, and nothing is sent to a rendering service. The only exception is transcription, which goes through ElevenLabs' Scribe API — your audio tracks therefore pass through the cloud at that step. For sensitive content, this is the only point to audit.

Do you need a high-end model to drive the pipeline?

For standard footage logging, mid-tier models like Claude Sonnet 4.6 or GPT-5.3 Codex are enough. Complex scenarios — nuanced editing strategies, elaborate overlays — benefit from top-tier models like GPT-5.5 or Claude Opus 4.7 Adaptive. Self-hosted options like Kimi K2.6 or GLM-5 offer a way to keep costs under control at volume.

Does it replace Premiere Pro or CapCut?

No, and that's not the goal. video-use automates a category of tasks — footage logging, cleanup, subtitles, basic color grading — not the creative craft of editing. The two approaches are complementary: the agent produces a clean, reproducible base, while the human keeps control over the narrative choices. That boundary will shift with upcoming releases.

✅ Conclusion

Video editing has just become an agentic task rather than an interface — and video-use, with its 27,574 stars earned in six months, is the first large-scale demonstration of this. Try it out on your next batch of footage, and follow the evolution of this wave in our AI news roundup.