How to Use OpenMontage: A Real, No-Fluff Setup Guide (2026)

Updated October 31, 2026, with every figure re-checked against the project's README, its GitHub page and openmontage.video. When this guide first ran in June 2026, OpenMontage had about 29k stars, 52 tools and no website. Since then it has added the Backlot storyboard, more providers, and a website for a Windows desktop app in private alpha. Its reference-video mode was already there in June; our first version just didn't cover it.

OpenMontage, "the first open-source, agentic video production system", turns your AI coding assistant into a video studio: you describe a video, and an agent researches, scripts, sources, edits and renders it, with your approval at each creative step. It hit #1 on GitHub Trending, and by late October 2026 it had about 73,000 stars and 9,600 forks.

The short version: install Git, Python 3.10+, Node.js 18+ and FFmpeg; run git clone https://github.com/calesthio/OpenMontage.git, cd OpenMontage, make setup and make demo; then open the folder in Claude Code, Cursor, GitHub Copilot, Windsurf or Codex and describe the video you want. Windows without make has a PowerShell setup, below.

What OpenMontage actually is

OpenMontage (github.com/calesthio/OpenMontage; you'll also see it written as "Open Montage") is open source under AGPL-3.0, and the repo is self-hosted: you download it, run it on your own machine and operate it through an AI coding assistant. Its website, openmontage.video, is about a separate desktop app, OpenMontage Studio (below).

The repo's GitHub description counts 12 production pipelines, 100+ tools and 700+ agent skill and production-knowledge files, and the README counts 60+ provider integrations. The agent reads YAML pipeline manifests and markdown "director skills", picks providers with a scored selector, tracks spend against a budget, and renders with Remotion (React), HyperFrames (HTML/GSAP) or FFmpeg.

It's general-purpose video: animated explainers, documentary montages cut from real stock and archive footage, talking heads, avatar spokespeople, cinematic trailers, screen demos, a clip factory that cuts one long source into ranked shorts, podcast repurposing, and localization and dubbing.

What you need before you start

• Git: to download the repo with git clone.
• Python 3.10+: the tool registry and pipeline engine run on it.
• Node.js 18+: Remotion composition is React-based. The README lists HyperFrames renders as needing Node 22 or newer.
• FFmpeg: the workhorse for encoding, subtitles, mixing and stitching.
• An AI coding assistant: Claude Code, Cursor, GitHub Copilot, Windsurf or Codex, on your own subscription or API usage. This is non-negotiable; the agent is the operator.
• A GPU only for local generation. Local video and image models, plus local upscaling and face restoration, want one; the cloud-provider and zero-key paths run on an ordinary machine.

Installing it

git clone https://github.com/calesthio/OpenMontage.git
cd OpenMontage
make setup
make demo

make setup creates a .venv virtual environment (unless one is already active), installs the Python requirements, the Remotion composer, Piper for free offline narration and the HyperFrames runtime, then creates your .env from .env.example if you don't have one yet. Activate the environment (source .venv/bin/activate) before you run Python commands yourself. make demo renders a few zero-key demo videos (animated charts, text and data visuals), so you know the install works before you add a single key.

On Windows without make, run the README's PowerShell setup from the repo folder:

py -3 -m venv .venv; .\.venv\Scripts\Activate.ps1; python -m pip install -r requirements.txt; cd remotion-composer; npm install; cd ..; python -m pip install piper-tts; Copy-Item .env.example .env

Then run python render_demo.py in place of make demo. If npm install fails with ERR_INVALID_ARG_TYPE, run npx --yes npm install instead. The README has a similar one-liner for macOS and Linux.

Have a GPU? make install-gpu adds the local-generation Python dependencies; then set VIDEO_GEN_LOCAL_ENABLED=true and pick a local model (WAN 2.1/2.2, Hunyuan, LTX-Video or CogVideo) in .env. The Makefile mentions NVIDIA, and the repo's docs include a separate guide for Apple Silicon Macs.

Then open the project folder in your AI coding assistant. That's where you actually work.

How you actually drive it

You don't click buttons. You describe the video in plain language, and the agent picks a pipeline and runs it:

research -> proposal -> script -> scene_plan -> assets -> edit -> compose

The agent researches first (per the README, 15 to 25+ web searches across YouTube, Reddit, news and academic sources), then proposes concepts, a tool plan and a cost estimate. When both Remotion and HyperFrames are installed, it lays out both render runtimes for you to pick before locking one in. Then it writes the script and scene plan, generates or fetches footage, images, voice and music, and assembles and renders. A mandatory post-render self-review (ffprobe validation, sampled frames, audio levels, delivery-promise and subtitle checks) runs before you see anything.

Approval gates are enforced, not suggested: the proposal, script, scene plan, generated assets and publish step all pause for your sign-off. So a prompt like "make a 60-second explainer about how compost works, documentary style, calm narration" starts the chain, and you steer it at each gate.

Start from a video you already love

Instead of a blank prompt, you can hand the agent a YouTube video, Short, Reel, TikTok or local clip:

"Here's a YouTube Short I love. Make me something like this, but about quantum computing."

The agent analyzes the transcript, pacing, scenes, keyframes and style, then comes back with 2 to 3 differentiated concepts, the tool path it would use, a cost estimate at your target length and a sample before full production. Per the README, it spells out what it keeps from the reference (pacing, hook style, structure, tone) and what it changes (topic, visual treatment, angle, narration approach). One of the README's example prompts: "Analyze this Reel and give me 3 original variants I could make for my own product launch." How close the result gets to a polished short depends on the providers you've connected.

Watch it happen with Backlot

Backlot is a local live storyboard that the agent opens when a production starts. It fills in from the project files as the pipeline runs, showing each stage, the script, scene cards, and every provider decision and dollar spent. To open it yourself:

python -m backlot open                  # every project on disk
python -m backlot open <project-id>     # one production's live board
python scripts/backlot_simulate_run.py  # no production yet? watch a simulated one

Asset generation pauses on its contact sheet (takes, prompts, per-asset cost, quality scores) until you approve the visuals, and REPLAY RUN replays a finished production from its timestamps.

OpenMontage Studio and openmontage.video

The website is about OpenMontage Studio, a desktop app from the same team. As of October 31, 2026, the site says:

• It's a Windows desktop app in private alpha, with beta invitations going to the waitlist in weekly groups (the site shows 25,000+ people on it).
• You describe a video, image, sound or animation, and agents plan, make and edit it with you; you see the production plan before anything is generated.
• It works with Claude Code and Codex on your own account, and with your own media-provider accounts, free local tools or OpenMontage credits. The site also describes an OpenMontage plugin that brings the same tools into a Claude Code or Codex session.
• It runs on your computer, and what you make has no watermark.
• Prices aren't final; the team says it will share them with the waitlist before the beta.

Unless you're invited, the open-source repo is how you use OpenMontage today. Use the website link in the official README rather than lookalike pages.

Using OpenMontage with Claude Code, Cursor, Copilot or Codex

Each assistant gets its own instruction file (CLAUDE.md, CURSOR.md plus .cursor/rules/, COPILOT.md plus .github/copilot-instructions.md, CODEX.md, .windsurfrules), and all of them point to the same AGENT_GUIDE.md, so the pipeline is identical. What differs is permissions and long renders:

• Claude Code: open the folder and describe the video. Approve shell commands the first time the agent runs make, FFmpeg or Node, and let long renders run in the background.
• Cursor: use Agent mode, not inline chat, so it can execute commands instead of only proposing them.
• Codex: point it at the project root so it finds the skills, then describe the job. If a run stalls, ask it to re-run only the failed stage; checkpoints make runs resumable.

In all of them, keep one video per conversation so two jobs' files and approvals don't get mixed.

Free local path vs. paid API keys

OpenMontage is "bring your own keys": every key is optional, and more keys unlock more tools. Paid options include fal.ai (FLUX, Veo, Kling, MiniMax), Atlas Cloud (Kling, Seedance and Hailuo), the official Kling API, Seedance 2.0 through Volcengine Ark, MiniMax H3, Gemini Omni Flash, Runway, HeyGen, ElevenLabs, OpenAI, Google, xAI and Suno. You pay those vendors directly.

With zero keys, make setup still gives you Piper narration, footage from Archive.org, NASA and Wikimedia Commons, Remotion and HyperFrames composition, FFmpeg post-production and word-level subtitles. Pexels, Pixabay and Unsplash add more stock with free developer keys. The README calls its free routes "free-ish": image-based video (narration over animated stills), local SVG character animation, and the real-footage documentary montage, where the agent searches a corpus of open footage and cuts actual motion clips together. For that one, ask for a "documentary montage" and say "use real footage only".

The local models (set up under Installing it) run at no API cost. OpenMontage can also drive a ComfyUI server (localhost:8188 by default, or COMFYUI_SERVER_URL in .env), with bundled workflows for WAN 2.2 video, FLUX.2 images and ACE-Step music. ComfyUI Partner Nodes are the exception to "free": they call hosted models and need a logged-in Comfy account and credits.

What it really costs

OpenMontage itself is free under AGPL-3.0. Your costs are the media API calls plus the AI coding assistant that drives it, on your own subscription or API usage (the README lists local LLMs through Ollama and LM Studio as coming soon). For businesses, one more line item: the Remotion renderer has its own license, free for individuals, non-profits and companies of up to 3 employees, while larger for-profit companies need a Remotion company license.

The README's media-cost ranges:

The project's showcase videos add real data points: a 60-second animated short built on six Kling clips cost $1.33 in total, and a 50-second vertical film with five generated scenes cost about $4. By default the agent pauses for approval before any single action estimated over $0.50, and each project gets a $10 budget; in the default warn mode going over it is logged rather than blocked, and cap mode makes it a hard limit. Both are configurable. Older guides, including the first version of this one, quoted "$0.02 to $1.33 per short video"; use the ranges above.

Time and quality vary too. The prompt gallery's estimates run from 3 to 5 minutes for a zero-key HyperFrames promo to 25 to 40 minutes for a full-setup cinematic trailer, renders can take iterations, and quality depends on which providers you wire up. For a developer who wants to self-host and customize anything (swap providers, edit pipelines, add tools), it's a strong foundation.

If you'd rather not self-host

Riffkit, which publishes this guide, is a hosted tool for short-form video. OpenMontage can start from a video you like too, so the real differences are setup and scope: Riffkit runs in the browser and inside Claude (as a connector or an agent skill) with no repo, Python, Node, API keys or GPU, and it quotes each video's price before it renders. Adapt remakes a winning short video's formula (hook, pacing, emotional beats) as new footage for your product, in any of 10 languages. Swap keeps a clip's shots, cuts, timing and sound and changes the person, an outfit someone in the clip wears, the setting, or a product (from your photos of it), as in our outfit-change test. Billing is by the second of finished video, with plans from $15/mo. Our OpenMontage alternative post covers per-video prices, music and footage rights, and a side-by-side. If you want to self-host and customize the whole pipeline, OpenMontage is the better fit, so go star it.

To try Riffkit from an agent, tell your assistant: Read https://riffkit.ai/SKILL.md and follow the instructions to set up Riffkit. The skill is open source at github.com/riffkit/skill.