How to Set Up and Run Video‑Use on a VPS for Continuous Video Editing

Video‑use is a conversation‑driven video editor that runs as an LLM agent skill on a VPS, automatically transcribing footage with ElevenLabs Scribe, generating cut plans via packed transcripts, and rendering final videos with FFmpeg when new files appear.

Setting up video‑use on a VPS enables continuous, automated video editing workflows. This open‑source skill from the browser-use/video-use repository functions as a self‑contained module that integrates with LLM agents like Claude Code, Codex, or Hermes. When you set up and run video‑use on a VPS for continuous video editing, you create a persistent environment that monitors directories, processes raw footage through a five‑layer pipeline, and delivers publication‑ready videos without manual intervention.

Prerequisites

Before installation, ensure your VPS meets the base requirements. You need FFmpeg on $PATH for all video operations, and Python 3 for the helper scripts.

On Ubuntu or Debian systems:

sudo apt-get update
sudo apt-get install -y ffmpeg python3-pip

Install yt-dlp only if your workflow downloads remote sources:

pip3 install --user yt-dlp

Installation Steps

Clone the Repository to a Stable Location

Clone video‑use to a permanent location. The documentation references ~/Developer/video-use, but /opt/video-use works for system‑wide VPS deployment:

sudo mkdir -p /opt/video-use
sudo chown $USER:$USER /opt/video-use
git clone https://github.com/browser-use/video-use /opt/video-use

Install Python Dependencies

The repository is an editable Python package defined in pyproject.toml. While pip works universally, uv is the preferred installer for faster resolution:

cd /opt/video-use
command -v uv >/dev/null && uv sync || pip install -e .

This installs required libraries including requests, librosa, and numpy.

Configure the ElevenLabs API Key

video‑use relies on ElevenLabs Scribe for word‑level transcription. Create a .env file at the repository root with restrictive permissions:

cat > /opt/video-use/.env <<EOF
ELEVENLABS_API_KEY=YOUR_ELEVENLABS_KEY_HERE
EOF
chmod 600 /opt/video-use/.env

The helpers/transcribe.py module reads this key; never expose it in logs or version control.

Registering the Skill with Your LLM Agent

The skill must be symlinked into your agent’s skills directory so that helpers remain adjacent to SKILL.md. For Claude Code:

mkdir -p ~/.claude/skills
ln -sfn /opt/video-use ~/.claude/skills/video-use

For other agents like Codex or Hermes, adjust the target path accordingly (see install.md for agent‑specific directories).

Verify the installation by loading the Python modules:

python -c "import helpers.transcribe; import helpers.render; print('All modules loaded')"

Configuring the Continuous Editing Pipeline

Directory Structure

All session artifacts live under <videos_dir>/edit/ as defined in SKILL.md. The LLM agent reads edit/takes_packed.md (generated by helpers/pack_transcripts.py) and writes cut decisions to edit/edl.json. The render layer outputs edit/final.mp4 after processing.

Create the Watchdog Script

To achieve continuous operation, deploy a watchdog script that monitors a raw footage folder and triggers the agent. Create edit-loop.sh:

#!/usr/bin/env bash
set -euo pipefail

RAW_DIR=/var/video-raw
mkdir -p "$RAW_DIR"

while true; do
  if compgen -G "$RAW_DIR/*.{mp4,mov,avi}" > /dev/null; then
    echo "New footage detected – launching agent"
    cd "$RAW_DIR"
    claude <<'PROMPT'
edit these into a launch video
PROMPT
    
    if [[ -f edit/final.mp4 ]]; then
      echo "Render complete – moving to output"
      cp edit/final.mp4 /var/www/html/latest.mp4
    fi
  fi
  sleep 30
done

Make the script executable and run it under a process manager like systemd or supervisord to survive reboots:

chmod +x edit-loop.sh

Understanding the Video‑Use Architecture

The skill operates through five distinct layers as implemented in browser-use/video-use:

1. Transcription Layer – helpers/transcribe.py calls ElevenLabs Scribe to produce word‑level JSON transcripts for each input file.
2. Packing Layer – helpers/pack_transcripts.py merges all JSON transcripts into a compact takes_packed.md that the LLM reads to understand the raw material.
3. Decision Layer – The LLM reasons over the packed transcript, proposes an Edit Decision List (EDL), and awaits user confirmation.
4. Render Layer – helpers/render.py extracts per‑segment clips, applies colour‑grading via helpers/grade.py (supporting presets like warm_cinematic), adds animation overlays, and burns subtitles (hard‑rule 1).
5. Self‑Evaluation – helpers/timeline_view.py generates film‑strip PNGs and waveform visualizations to verify audio pops, subtitle visibility, and overlay timing before the final output is presented.

Optional: Animation Engine Setup

For HyperFrames or Remotion animations, install Node.js 22+:

curl -fsSL https://deb.nodesource.com/setup_22.x | sudo -E bash -
sudo apt-get install -y nodejs

For Manim animations, install via pip when first required:

pip install manim

The skill lazily installs specific animation dependencies inside edit/animations/slot_<id>/ directories as needed.

Summary

• Set up and run video‑use on a VPS for continuous video editing by cloning the repository to a stable path like /opt/video-use and symlinking it into your LLM agent’s skills directory.
• Install system dependencies (ffmpeg), Python packages (via uv or pip), and the ElevenLabs API key in a secured .env file.
• The architecture relies on helpers/transcribe.py for audio‑to‑text, helpers/pack_transcripts.py for LLM‑readable formatting, and helpers/render.py for final output generation.
• Deploy a watchdog bash script to monitor folders, trigger the agent, and collect edit/final.mp4 automatically.
• Store all working files under <videos_dir>/edit/ and verify renders with helpers/timeline_view.py before distribution.

Frequently Asked Questions

How does video‑use handle transcription costs on a VPS?

The skill uses helpers/transcribe.py to call ElevenLabs Scribe via API. Each video file is transcribed once and cached as JSON in the edit/ directory. The packed transcript (takes_packed.md) references these cached files, so restarting the agent or re‑editing does not incur additional transcription costs unless you add new source footage.

Can I run video‑use without Claude Code?

Yes. The skill is agent‑agnostic. While the installation guide uses Claude Code paths (~/.claude/skills/), you can symlink the repository into any LLM agent’s skill directory that supports the skill pattern (Codex, Hermes, or custom implementations). The core logic resides in SKILL.md and the helpers/ directory, which any compliant agent can execute.

What happens if the render process fails mid‑way?

helpers/render.py processes video segments atomically where possible. If a render interrupts, check edit/ for partial outputs. The skill supports preview mode (--preview flag) to generate low‑resolution test clips before committing to a full render, saving bandwidth and compute on your VPS. Always verify audio and subtitle alignment using helpers/timeline_view.py before finalizing.

Is continuous operation safe for production VPS environments?

Yes, provided you isolate the execution environment. Run the watchdog script under a dedicated user with restricted permissions, store your ELEVENLABS_API_KEY in a 600‑permission .env file, and mount the raw footage directory as read‑only when possible. The skill writes only to the configurable edit/ subdirectory, making it suitable for containerized or chrooted deployments.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}