How to Run video-use on a VPS with Always-On Access via Browser Use Box or Telegram

Deploy video-use on a VPS by cloning the repository into ~/Developer/video-use, installing Python dependencies and ffmpeg, registering the skill with your LLM agent, and wrapping the persistent session with Browser Use Box or Telegram to maintain a public, always-on editing endpoint.

The video-use repository by Browser Use provides an AI-powered video editing workflow that automates transcription, cutting, grading, and rendering through LLM agents like Claude Code or Codex. To run video-use on a VPS with always-on access via Browser Use Box or Telegram, you must configure a persistent environment that keeps the agent running continuously and exposes it through a public URL or messaging interface. This setup ensures you can trigger complex video editing tasks from any device without maintaining a local terminal connection.

Prerequisites and VPS Setup

Begin by preparing a stable directory structure and installing the required system dependencies. The video-use workflow requires Python 3, ffmpeg for media processing, and an ElevenLabs API key for transcription.

Clone and Install Dependencies

Create a dedicated directory and clone the repository:

mkdir -p ~/Developer && cd ~/Developer
git clone https://github.com/browser-use/video-use video-use
cd video-use

Install Python dependencies using uv (preferred) or pip:

command -v uv >/dev/null && uv sync || pip install -e .

Install ffmpeg and optionally yt-dlp for downloading source media:

sudo apt-get update && sudo apt-get install -y ffmpeg
pip install yt-dlp

Configure API Keys

The transcription pipeline requires an ElevenLabs API key. Copy the example environment file and add your credentials:

cp .env.example .env

# Edit .env to add: ELEVENLABS_API_KEY=your_key_here

chmod 600 .env

As documented in install.md, the skill automatically detects this key when exported as an environment variable or stored in the .env file.

Register the Skill with Your LLM Agent

The video-use workflow operates as a skill within your LLM agent. You must symlink the repository into the agent's skills directory. For Claude Code, execute:

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

Alternative registration paths for Codex, Hermes, and other agents are detailed in Step 5 of install.md.

Verify the Installation

Confirm that helper scripts and system dependencies are reachable before proceeding:

python helpers/timeline_view.py --help
ffprobe -version | head -1

Successful execution indicates that the core pipeline—including transcribe.py, render.py, and grade.py—is functional and ready for always-on deployment.

Configure Always-On Access

The repository itself does not contain a daemon; instead, it is designed to be driven by a persistent LLM agent session. To achieve always-on access, you must keep the agent running and expose it via Browser Use Box or Telegram.

Browser Use Box Setup

Browser Use Box provides a lightweight HTTP tunnel that exposes your LLM's REPL as a public URL (e.g., https://<your-box>.browser-use.com). According to the README.md, this allows you to "run the agent through Browser Use Box for always-on editing" from any device.

Create a startup script at ~/run_video_use.sh:

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

cd ~/Developer/video-use

# Start the LLM agent in background (adjust for your agent: claude, codex, etc.)

claude &

# Expose the REPL via Browser Use Box

browser-use-box --port 8000

Make the script executable:

chmod +x ~/run_video_use.sh

Telegram Bot Integration

When you enable Browser Use Box, the Browser Use platform automatically creates a Telegram bot bound to your persistent REPL. Users send natural language commands like "edit these into a launch video" to the bot, and the agent processes the request on the VPS. The README.md specifically references this capability for "always-on editing... via Telegram."

Persistent Session Management with tmux

To ensure the session survives SSH disconnections, launch the startup script under tmux or screen:

tmux new-session -d -s video-use '~/run_video_use.sh'

For production deployments, consider creating a systemd service that automatically restarts the agent and tunnel if the VPS reboots.

Execute the Video Editing Workflow

Once the always-on tunnel is active, you can initiate editing from any client (browser, Telegram, or another LLM). The workflow follows the strict process defined in SKILL.md:

1. Inventory: The agent scans source files using ffprobe and transcribe_batch.py
2. Propose Strategy: It generates cut points and color grading plans based on pack_transcripts.py output
3. Wait for Confirmation: Per Hard Rule #11 in SKILL.md, the agent pauses for explicit approval before rendering
4. Execute: Upon confirmation, it runs render.py, grade.py, and optional animation slots
5. Self-Evaluate: Finally, it runs timeline_view.py to verify the output before presenting the result

All generated media is written to <videos_dir>/edit/ (e.g., edit/final.mp4, edit/project.md), ensuring the skill directory remains clean and separated from media assets.

Example interaction via Telegram or Browser Use Box URL:

> edit these into a launch video

The agent replies with an inventory, asks clarifying questions, and after your confirmation outputs:

✅ Render complete → edit/final.mp4
📝 Session saved → edit/project.md

Summary

• Installation: Clone to ~/Developer/video-use, install via uv sync or pip install -e ., and install ffmpeg
• Configuration: Set ELEVENLABS_API_KEY in .env and symlink the skill to ~/.claude/skills/video-use
• Always-On Setup: Wrap the LLM agent with browser-use-box --port 8000 running under tmux for persistence
• Access Methods: Connect via public Browser Use Box URL or the auto-provisioned Telegram bot
• Workflow Compliance: The agent follows hard rules from SKILL.md, including confirmation checkpoints and output isolation to <videos_dir>/edit/

Frequently Asked Questions

How do I keep the video-use agent running after disconnecting from SSH?

Launch the agent and Browser Use Box inside a tmux or screen session. For example: tmux new-session -d -s video-use './run_video_use.sh'. This detaches the process from your terminal, allowing the VPS to maintain the always-on endpoint indefinitely.

Where does video-use store generated files to avoid polluting the repository?

According to the Directory layout section in SKILL.md, all generated media is written to <videos_dir>/edit/ (e.g., edit/final.mp4). The skill never writes into its own repository folder, maintaining a strict separation between code and media assets.

Which helper scripts handle the transcription and rendering pipeline?

The workflow utilizes helpers/transcribe_batch.py for parallel audio transcription via ElevenLabs, helpers/pack_transcripts.py to generate edit/takes_packed.md for LLM consumption, and helpers/render.py to execute the final extraction, grading, and subtitle burning. The helpers/timeline_view.py script provides visual previews for verification.

Can I use video-use without Claude Code?

Yes. While the examples reference Claude Code, the skill registration in install.md supports Codex, Hermes, and other LLM agents that follow the skill directory convention. Adjust the symlink target from ~/.claude/skills/ to your agent's specific skills path.

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