browser-use/video-use: Edit Videos with Claude Code Agents

browser-use/video-use: Edit Videos with Claude Code Agents

Raw footage piles up. Sifting through takes, cutting filler, matching color between clips, burning subtitles — the work is tedious and repetitive. Most editing software buries these tasks behind menus and presets that assume you already know what you want. For developers who think in code and prefer conversational interfaces, traditional video editors feel like the wrong abstraction entirely.

Enter browser-use/video-use, an open-source Python^{↗ Bright Coding Blog} project that lets you edit videos by chatting with coding agents like Claude Code, Codex, or Hermes. Drop footage in a folder, describe what you want, and get final.mp4 back. No timeline scrubbing, no preset hunting. The tool has accumulated 16,913 GitHub stars and 2,124 forks as of its last commit on July 1, 2026, suggesting genuine traction among developers who want programmatic control over video production.

This article breaks down how browser-use/video-use works, what it actually delivers, and how to set it up without surprises.

What is browser-use/video-use?

browser-use/video-use is a skill package for AI coding agents that enables text-driven video editing. Released under the MIT License and written primarily in Python, it is maintained by the same team behind browser-use — a project that gives LLMs structured DOM access instead of screenshots for web automation.

The core insight is identical: instead of feeding an LLM raw video frames (expensive, noisy), browser-use/video-use gives it structured text representations of the audio content, supplemented by on-demand visual composites only at decision points. This keeps token costs low and reasoning precise.

The project is 100% open source. It integrates with ElevenLabs Scribe for transcription, ffmpeg for rendering, and supports animation generation through HyperFrames, Remotion, Manim, or PIL. Session state persists in a local project.md file, so multi-day projects resume cleanly.

The timing matters. As coding agents like Claude Code and Codex mature, developers increasingly expect to control complex creative tools through conversation rather than GUIs. browser-use/video-use sits at this intersection: it treats video editing as a software engineering problem, not a media production problem.

Key Features

Word-level precision from audio transcripts. The tool calls ElevenLabs Scribe once per source file, producing timestamps for every word, speaker diarization, and audio event tags like (laughter) or (applause). All takes compress into a single ~12KB takes_packed.md — the LLM's primary working surface.

Filler removal and dead-space cutting. The agent identifies umm, uh, false starts, and silence gaps between takes, proposing cuts at speech boundaries rather than arbitrary frame positions.

Automatic color grading. Every segment gets graded via ffmpeg chains — warm cinematic, neutral punch, or custom filters you define.

Audio pop prevention. 30ms fades at every cut boundary eliminate the clicks and pops that betray amateur edits.

Subtitle burning. Defaults to 2-word UPPERCASE chunks, but fully customizable in style and timing.

Parallel animation generation. Spawns sub-agents for overlays via HyperFrames, Remotion, Manim, or PIL — one agent per animation, running concurrently.

Self-evaluation loop. After rendering, the tool runs timeline_view on the output at every cut boundary to catch visual jumps, audio pops, and hidden subtitle issues. Failures trigger up to three automatic re-renders before showing you anything.

Session persistence. All project state lives in project.md, so tomorrow's session starts where today's ended.

Use Cases

Launch videos and product demos. Record multiple takes of a screen recording or talking-head segment. The agent inventories sources, proposes a cut strategy, and produces final.mp4 after your approval. No manual alignment of flubbed lines.

Interview editing. Multi-speaker diarization lets you strip crosstalk, dead air, and interviewer prompts automatically. The transcript view makes it trivial to verify which speaker said what before cutting.

Tutorial content. Consistent subtitle styling across episodes, automatic removal of "um" and "uh" from instructional speech, and color grading that matches your channel's look without per-episode manual adjustment.

Travel and event montages. Drop footage from multiple cameras or days. The agent proposes chronological or thematic structures based on transcript content, not just file timestamps.

Iterative creative work. Because session state persists, you can render a draft, review it days later, and resume with context intact — the agent remembers previous decisions and rejected takes.

Installation & Setup

The fastest path uses your existing coding agent. Paste this prompt into Claude Code, Codex, Hermes, Openclaw, or any agent with shell access:

Set up https://github.com/browser-use/video-use for me.

Read install.md first to install this repo, wire up ffmpeg, register the skill with whichever agent you're running under, and set up the ElevenLabs API key — ask me to paste it when you need it. Then read SKILL.md for daily usage, and always read helpers/ because that's where the editing scripts live. After install, don't transcribe anything on your own — just tell me it's ready and wait for me to drop footage into a folder.

The agent handles cloning, dependencies, skill registration, and prompts once for your ElevenLabs API key. Get one at elevenlabs.io/app/settings/api-keys.

For manual installation:

# 1. Clone and symlink into your agent's skills directory
git clone https://github.com/browser-use/video-use ~/Developer/video-use
ln -sfn ~/Developer/video-use ~/.claude/skills/video-use        # Claude Code
# ln -sfn ~/Developer/video-use ~/.codex/skills/video-use       # Codex

# 2. Install deps
cd ~/Developer/video-use
uv sync                         # or: pip install -e .
brew install ffmpeg             # required
brew install yt-dlp             # optional, for downloading online sources

# 3. Add your ElevenLabs API key
cp .env.example .env
$EDITOR .env                    # ELEVENLABS_API_KEY=...

After setup, navigate to your footage folder and start the agent:

cd /path/to/your/videos
claude    # or codex, hermes, etc.

Then simply tell it: edit these into a launch video. The agent inventories sources, proposes strategy, waits for confirmation, and writes outputs to <videos_dir>/edit/ — keeping the skill directory clean.

Real Code Examples

The README provides two primary interaction patterns. First, the setup prompt that configures the entire environment through agent conversation:

Set up https://github.com/browser-use/video-use for me.

Read install.md first to install this repo, wire up ffmpeg, register the skill with whichever agent you're running under, and set up the ElevenLabs API key — ask me to paste it when you need it. Then read SKILL.md for daily usage, and always read helpers/ because that's where the editing scripts live. After install, don't transcribe anything on your own — just tell me it's ready and wait for me to drop footage into a folder.

This is not traditional "code" but it is the primary interface — natural language instructions that the agent translates into shell commands, file operations, and configuration. The prompt explicitly directs the agent to documentation files (install.md, SKILL.md, helpers/) rather than improvising, ensuring consistent setup across environments.

Second, the manual installation sequence for developers who prefer direct control:

# Clone and create skill symlink for agent discovery
git clone https://github.com/browser-use/video-use ~/Developer/video-use
ln -sfn ~/Developer/video-use ~/.claude/skills/video-use

# Install Python dependencies (uv preferred, pip fallback)
cd ~/Developer/video-use
uv sync

# Install system dependencies
brew install ffmpeg             # Core rendering pipeline
brew install yt-dlp             # Optional: online source ingestion

# Configure API credentials
cp .env.example .env
$EDITOR .env                    # Add ELEVENLABS_API_KEY=...

The ln -sfn symlink is critical — it registers the skill in the agent's search path without copying files, so updates to the repo reflect immediately. The uv sync command uses the modern Python package manager; the pip install -e . fallback ensures compatibility with older workflows.

The README does not provide additional code snippets for runtime usage. The actual editing commands are conversational (edit these into a launch video), with the agent generating and executing the underlying Python/ffmpeg calls transparently.

Advanced Usage & Best Practices

Let the agent read before acting. The README emphasizes reading install.md, SKILL.md, and helpers/ in sequence. Skipping this risks misconfigured ffmpeg paths or missing skill registration.

Use the transcript as your review surface. The ~12KB takes_packed.md is designed for human scanning. Verify proposed cuts there before approving render — it's faster than watching previews.

Customize via ffmpeg chains. The color grading accepts any valid ffmpeg filter graph. Warm cinematic and neutral punch are defaults, but the pipeline is unopinionated about your look.

Leverage parallel animation carefully. Each animation spawns its own sub-agent. For complex projects, this speeds execution but increases API costs proportionally.

Trust the self-eval loop. The three-attempt re-render limit catches most technical errors. If it fails after three, the issue is likely in source quality or strategy, not rendering.

Persist sessions intentionally. The project.md file is plain text — version it with your footage for reproducible workflows.

For always-on editing from a VPS or Telegram, consider Browser Use Box ([INTERNAL_LINK: remote-agent-hosting]).

Comparison with Alternatives

browser-use/video-use occupies a distinct niche: developers who already use Claude Code or similar agents, and who want the reasoning layer of an LLM applied to editorial decisions without surrendering programmatic control. Descript is more accessible for non-programmers; raw ffmpeg offers more control for those willing to build abstractions themselves. Remotion overlaps on programmatic generation but lacks the agentic reasoning and transcript-driven editing model.

FAQ

What agents are supported? Claude Code, Codex, Hermes, Openclaw, or any agent with shell access and skill registration.

Is ElevenLabs required? Yes — Scribe provides the word-level transcripts that drive the entire pipeline.

What video formats work? Anything ffmpeg reads. The tool is format-agnostic by design.

Can I use this commercially? Yes — MIT License permits commercial use.

Does it work offline? Partially. Transcription requires ElevenLabs API access. Rendering with cached transcripts can run locally.

How much does it cost? The tool itself is free. You pay for ElevenLabs API usage and any LLM agent costs.

What if the self-eval loop fails? After three re-render attempts, it surfaces the issue for manual review rather than hiding errors.

Conclusion

browser-use/video-use is a pragmatic tool for a specific user: developers who already live in coding agents, who find traditional video editing software frustratingly GUI-bound, and who want editorial decisions grounded in transcript data rather than visual scrubbing.

It is not a replacement for professional colorists or narrative editors working on feature films. It is a force multiplier for the repetitive, structured work that consumes most online video production — tutorials, interviews, product launches, talking heads.

The 16,913 stars and active fork community suggest the approach resonates. If your workflow already includes Claude Code or similar agents, and you regularly produce video content, the setup cost is low and the payoff is meaningful automation of tedious editorial tasks.

Start at the source: https://github.com/browser-use/video-use