Oh My Cassette: Chat Your Raw Clips Into a Finished Cut

简体中文 | English

Point Claude Code, Codex, or Hermes at a folder of raw clips.
Describe the video you want. Get back a finished, beat-synced cut.

14 clips in. One prompt. ~13 minutes to a rendered file.
_{No timeline. No editing software. No GPU.}

⚡ Install in 30 seconds

# Claude Code
claude plugin marketplace add Cassette-Editor/oh-my-cassette
claude plugin install oh-my-cassette@cassette-editor

# Codex
codex plugin marketplace add https://github.com/Cassette-Editor/oh-my-cassette.git
codex plugin add oh-my-cassette@cassette-editor

Restart your agent, then say: "Edit the clips in ./footage into a 30-second travel vlog with beat-synced cuts."

Want to try the workflow before installing? Open the public web demo.

Needs Python 3.11–3.13, ffmpeg, and a Cassette account. Full setup — including OpenCode, Hermes, and any other MCP host — is in Quick Start.

🎥 Overview

Oh My Cassette is an open-source AI video editing plugin and local MCP server for Claude Code, Codex, Hermes Agent, and OpenCode. It turns natural-language chat into finished montage videos on Cassette — beat-synced cuts, auto-matched music, subtitles, transitions, and picture-in-picture — with minimal token overhead.

The agent does the parts that make editing tedious: it watches every clip, picks the shots, plans the cut, syncs it to the beat, and renders — while you stay in chat. Because it runs through your agent, you can do all of it from your phone.

🖥️ How it works

Upload your clips, describe the video you want, and the agent edits it.

The cut it produced

_{The screen recording is compressed to keep this page light, so the terminal text looks softer here than it does on your machine; the cut below it is the full-quality render. Prompt to rendered file took 9 minutes 53 seconds of real time, sped up above. A person's face is pixelated in both the screen recording and the cut it produced, for privacy — that blur is not something the agent added.}

_{Token cost: that session used 55K output tokens and 2.33M billed input tokens (2.07M of them cache reads) on Claude Opus 5 — roughly $4 at API list price, measured from the Claude Code transcript of this exact recording. One brief, one turn, start to exported file. The editing itself runs on Cassette, so the agent only pays for the brief and the timeline digests, not for the footage.}

🎬 Case Videos

Every case below was edited end-to-end by an AI agent through Oh My Cassette, from the exact prompt shown — real inputs, real processing times, and the output is what the agent delivered.

→ See all six cases — daily vlog, cinematic short, and game highlights, each with its exact prompt.
_{★ More cases are on the way. Star the project to follow along.}

🚀 Quick Start

Before You Start 🎬

Oh My Cassette connects Codex, Claude, or Hermes to the Cassette Agent. You need:

• Codex, Claude Code, or a working Hermes Agent installation.
• A Cassette account.
• For Hermes only, a configured gateway such as QQ or Telegram.

[!TIP] Apply for a Cassette account here: Cassette Sign Up

If you plan to use Hermes and it is not installed yet:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

If the Hermes Agent gateway is not configured yet:

hermes gateway setup

Oh My Cassette currently supports QQ and Telegram gateways.

Requirements

• macOS, Linux, or Windows for the local MCP plugin (Codex, Claude Code, or OpenCode). The Hermes Agent gateway path is macOS/Linux only.
• Codex, Claude Code, or OpenCode for the local MCP plugin, or Hermes Agent with its gateway configured.
• Python 3.11–3.13.
• ffmpeg, required for Hermes gateway normalization and optional API export thumbnails.

Supported video uploads

Cassette currently accepts video source files that match all of the following limits:

MOV, HEVC/H.265, AV1, VP9, ProRes, HDR, 10-bit, variable-frame-rate video, 24/25/50/60 fps, 4K, oversized files, and videos longer than 60 minutes are rejected rather than transcoded in the cloud.

Upload retention

Uploaded videos and plugin-managed previews, job state, and exports share one immutable 24-hour deadline measured from the session's first ingest. After that deadline the plugin removes its local copies and the service removes its media; another session — even on the same host or the same account — cannot reach them. Keep your own copy of every source file, and move any export you want to retain outside the plugin-managed data directory before the deadline.

Install system tools:

# macOS
brew install uv ffmpeg

# Debian/Ubuntu Linux
sudo apt-get update
sudo apt-get install -y ffmpeg
curl -LsSf https://astral.sh/uv/install.sh | sh

# Windows (PowerShell)
winget install Python.Python.3.13
winget install Gyan.FFmpeg

Install

Codex

codex plugin marketplace add https://github.com/Cassette-Editor/oh-my-cassette.git
codex plugin add oh-my-cassette@cassette-editor

Start a new Codex task after installation so plugin discovery runs again. The plugin contributes the host-neutral cassette-video-edit and cassette-model skills plus a local MCP process named cassette. Fresh editing sessions use GPT-5.6 Luna with Extra High thinking; invoke $cassette-model only when you want to inspect or change that session setting.

Claude Code

claude plugin marketplace add Cassette-Editor/oh-my-cassette
claude plugin install oh-my-cassette@cassette-editor

Restart Claude Code after installation. You can verify the installation with:

claude plugin details oh-my-cassette@cassette-editor

Claude Code can keep the plugin up to date on its own once you enable auto-update for the marketplace — see Update.

Fresh editing sessions use GPT-5.6 Luna with Extra High thinking. Invoke /cassette-model when you want to inspect or change the current session's model and thinking level.

OpenCode

OpenCode's plugin manager installs npm packages only, and its plugins cannot contribute MCP servers, so there is no marketplace entry to add. One command instead:

curl -fsSL https://raw.githubusercontent.com/Cassette-Editor/oh-my-cassette/release/scripts/install_opencode.py | python3 -

That downloads the current release, writes the cassette server into ~/.config/opencode/opencode.json (merging with any servers and settings already there), installs the host-neutral skills into ~/.config/opencode/skills/, and installs /cassette-model into ~/.config/opencode/commands/. Restart OpenCode afterwards. Fresh editing sessions use GPT-5.6 Luna with Extra High thinking; the command changes the setting only when you invoke it.

Re-run the same command to update. Only git is not required — the release tarball is fetched with Python's standard library.

Cassette credentials are shared across Codex, Claude Code, OpenCode, and Hermes, so if you have already set up another host there is nothing more to do. Otherwise the installer prints the setup_local_mcp.py command to finish authentication. Jamendo uses the host-specific BYOK setup described below.

The plugin tree lands in ~/.oh-my-cassette (override with OMC_HOME). --dry-run previews the changes. If you prefer a git checkout, clone it and run the installer from there — it registers that tree and leaves it alone, and --sync fast-forwards it to the release channel.

Any other MCP host

The runtime is host-neutral, so any client that launches a local stdio MCP server can use it. Point the client at scripts/run_local_mcp.py (run with python3, or python on Windows) and set CASSETTE_RUNTIME_ADAPTER=mcp. The server ships full workflow guidance in its MCP instructions, and every tool returns a typed phase/next_action so a host without the packaged skill can still drive the flow. For the best experience, also install the cassette-video-edit and cassette-model skills (or equivalent system prompts). Generic clients can call cassette_config or ask in natural language to change the current session's model.

Letting an AI assistant do the install for you — Cline, or any agent with shell access? Point it at llms-install.md: a machine-readable setup guide covering the runtime pre-build, host registration, authentication, media roots, and verification.

Hermes

Install through the Hermes plugin manager (recommended):

hermes plugins install Cassette-Editor/oh-my-cassette

The Hermes installer prompts for your Cassette account email and password and saves them to ~/.hermes/.env. Then run the setup finisher — it configures the same stdio MCP server and canonical editing skill used by the other hosts, sets Hermes's tool timeout to 1800 seconds, detects ffmpeg/ffprobe, and lets you pick the Cassette region — and enable the thin gateway plugin:

python3 ~/.hermes/plugins/cassette/scripts/install_plugin.py --setup-only
hermes plugins enable cassette
hermes gateway restart

You can check the install status anytime from the Diagnose section.

git clone https://github.com/Cassette-Editor/oh-my-cassette.git
cd oh-my-cassette
python3 scripts/install_plugin.py

python3 scripts/install_plugin.py --copy --force

python3 scripts/install_plugin.py \
  --skip-plugin-enable \
  --skip-cassette-url \
  --skip-cassette-auth \
  --skip-jamendo-auth

Use with agent clients over local MCP

Codex, Claude Code, OpenCode, and Hermes use the same self-contained runtime. In this README, MCP server means a local child process connected over stdin/stdout: it opens no port. The separate Cassette backend remains the editing engine and continues to handle authentication, media processing, agent runs, project state, and rendering.

First-run authentication

Cassette passwords are generated by the server and emailed to you. You never choose one, and the plugin never invents one.

Missing credentials do not prevent the MCP process from starting. There are two ways to hand the password over.

In the conversation. Paste the password from your Cassette email and ask the agent to sign in; it calls the cassette_login tool, which verifies the account against Cassette before writing anything and then stores it privately. Nothing else is needed — no terminal, no browser. The trade-off is explicit: the password lands in your agent host's transcript on disk and is sent to the model provider for the rest of that conversation. If that is not acceptable to you, use the terminal instead.

In a private terminal. The command keeps the password out of the transcript entirely — it prompts with getpass, verifies the account before writing anything, and stores credentials in the platform-standard Oh My Cassette config directory. Every auth_required envelope carries the exact command for your install; from a git checkout it is:

python3 scripts/setup_local_mcp.py --email you@example.com

Credentials may also come from process environment variables. Environment values take precedence over protected local config, so cassette_login refuses to write a file that would be shadowed. Importing an existing Hermes .env is explicit and optional:

python3 scripts/setup_local_mcp.py --import-hermes

Either route creates config directories with mode 0700 and credential files with mode 0600, rejects symlinks and permissive files, and never persists access or refresh tokens.

Jamendo BYOK setup

Jamendo music matching is strictly bring-your-own-key for every local agent host. Create a read-only application in the Jamendo developer portal and copy its Client ID. A Client Secret is neither needed nor accepted.

In the conversation. Ask the agent to configure Jamendo, paste your Client ID, and it