Viggle Remake is an open, agent-first video-to-video stack on Hugging Face that recasts, restyles, and edits footage you already have the rights to change, while keeping motion, timing, and soundtrack. Viggle AI pairs two rank-256 LoRAs on MiniMax-H3 with sample.py, ComfyUI packs down to 12 GB cards, and an MCP server so Claude Code, Codex, or any MCP host can cut windows, paint keyframes, render on your GPUs, and splice the result. The card lists 20B parameters, 76,308 downloads last month, and demo films that recast entire music videos.
If you only want to try it, the Viggle app runs Remake without local weights. Builders who need custody of footage, audit logs, or batch renders should read the hardware table, license chain, and consent warnings below before cloning weights.
What shipped on the model card
The Viggle/Viggle-Remake repository is organized around two modes, each a PEFT LoRA on the base transformer:
| Mode | Flag | What it does |
|---|---|---|
| swap | --mode swap | Replace people and characters, including several at once |
| edit | --mode edit | Change objects, backgrounds, weather, or lighting |
Inputs follow MiniMax-H3’s six-section prompt format plus one to four painted reference frames (--ref), optionally pinned to source frame numbers (--pin). The model carries source audio; it does not synthesize new soundtracks.
Published examples on the card include a La La Land shot remade 22 ways, a 116-second recast of Uptown Funk, and a Matrix Reloaded burly-brawl clip with species swaps. Those clips illustrate what the LoRAs can do when keyframes and prompts are curated; they are not a guarantee your first agent run succeeds without iteration.
Downloads and quantization: the sidebar lists GGUF builds (Q4_K_M about 14.3 GB, Q6_K about 17.6 GB, Q8_0 about 22.3 GB) for lighter local paths. Full fidelity still expects the large MiniMax-H3 base download the README documents.
Agent-first workflow: MCP and render workers
Event bell triggering gears for agent-orchestrated video render windows
Image: explainx.ai
Viggle’s headline pitch is agent-first: give a coding agent a video and a sentence such as “recast the band as politicians” or “make it snow,” and let it find cuts, paint keyframes, render each window, check output, and return a finished film.
The card points to mcp/ on the repo:
- Install the MCP package (
pip install -e .on the server machine;pip install -e '.[worker]'where GPUs live). - Start one render worker per GPU with
viggle-remake-worker. - Run the bundled example script (the card cites codex driving White House Funk in about 1.5 hours on two GPUs).
That design sits next to production patterns other labs document. Stripe’s public Minions write-ups describe background coding agents with an environment and a path to engineer-reviewed pull requests; Viggle’s MCP does the same shape of work for video windows instead of git diffs. See our agent sandbox comparison for how teams isolate agent runtimes. If you are standardizing how agents touch media, compare our MCP security guide and the Agent Skills pattern before you point an agent at customer footage.
Context engineering note: long renders are split into 90–345 frame windows (17n+5 frames at 24 fps). The MCP tries to split on natural cuts. Known limits on the card include ~12 seconds per render pass, heavy base weight size, and drift when multi-shot clips run without pins.
Manual path: sample.py and ComfyUI
Dataset license folder icon for MiniMax H3 derivative weight terms
Image: explainx.ai
Not every shop will hand a music video to an agent on day one. Viggle keeps a manual sampler:
python Viggle-Remake/inference/sample.py --mode swap \
--video source.mp4 --prompt prompt.txt \
--ref ref1.png --ref ref2.png --pin 12 --pin 96 \
--frames 124 --short-edge 480 --seed 0 \
--base ./MiniMax-H3 --lora-repo ./Viggle-Remake --out out.mp4
The README says examples/demo.sh reruns one example per mode from examples/inputs/; if turbines stay in a scene that should be clear, or a pizza maker is unchanged, the LoRA did not load correctly.
Hardware routing from the card:
| Your GPU | Suggested path |
|---|---|
| None | Viggle app |
| 12–24 GB | ComfyUI int8 or GGUF workflows |
| 32 GB (e.g. RTX 5090) | MCP with Comfy worker; ~28 minutes per 1280×736 window of 345 frames |
| 80 GB+ | sample.py at bf16 or agent with viggle-remake-worker |
| 96 GB+ | Same, with headroom for parallel workers |
You must download MiniMaxAI/MiniMax-H3 base files (about 144 GB selective pull) plus Viggle-Remake LoRA and inference assets (~5.5 GB selective; full git-lfs clone is ~210 GB). Pruna’s P-H3-Image shows how the same base family also feeds still-image tooling; Remake is the moving-picture branch.
License, attribution, and consent
Weights are a Model Derivative of MiniMax H3, so the MiniMax H3 Community License governs redistribution and commercial use. The card repeats MiniMax requirements: mark modified files, ship the NOTICE, display “MiniMax H3” in commercial UIs, and obtain written authorization if products and services exceed US$20 million per year.
Viggle’s own attribution line for products built on Remake:
Powered by Viggle Remake (https://huggingface.co/Viggle/Viggle-Remake)
Read our open-weight license explainer before you ship a SaaS wrapper.
The intended use section is unusually blunt for a playful demo card. Viggle says the model will happily put a real person’s likeness into footage they never approved because identity comes from painted frames, not from an in-model consent check. Image editors upstream may block some misuse; Remake does not. Builders should label outputs as AI-generated, avoid non-consenting subjects, and read Section V.5 if they offer Remake as a service.
For broader synthetic-media policy context, see marketplace fights like Etsy’s unedited-photo rules and itch.io’s AI slop cleanup.
Prompting, keyframes, and quality control
Viggle points builders to PROMPTING.md for the six-section MiniMax-H3 format and for when to pin a painted frame to a source timecode. In practice, pins matter most on dialogue scenes and multi-shot sequences where the model otherwise drifts relative to the original edit. The card recommends up to four reference images; identity and wardrobe flow from those frames more than from text alone.
Treat each window as a unit test. When demo.sh fails to remove an object that should disappear, fix LoRA loading before you scale out to an agent loop. Lower-rank LoRAs (--rank 128 or --rank 64) shrink disk to about 1.34 GB / 0.67 GB with near-identical output, which helps CI machines that only sanity-check prompts.
If your team already uses MLX on Apple Silicon for language models, remember Remake still wants NVIDIA-class VRAM or the Comfy int8 path for video. Laptops can drive orchestration; renders belong on a worker box with ffmpeg on PATH, as the README requires.
How Remake fits the open video stack in late 2026
Remake is not a general world model. It is a conditional video-to-video adapter with strong motion preservation and soundtrack carry-through, aimed at creators who already hold rights to source footage. That niche overlaps research agents like StreamVibe (timing help in long videos) and production-oriented skills such as OpenMontage for Claude Code, but Remake’s differentiator is open weights plus an MCP driver for whole-film batches.
Cost realism: even with two GPUs, a 116-second recast is measured in hours, not minutes. Plan for worker pools, pinned keyframes on hard shots, and human review before you publish. If agents orchestrate renders, put AgentBeam or your own policy layer in front of tool calls that can enqueue paid GPU jobs or push finished files to social accounts, so a compromised agent cannot burn budget or post unreviewed likeness swaps.
What developers are saying
The Hugging Face card trended in early November; discussion on other forums is still thin. Treat early demos as creator reports, not benchmarks. The card’s own limitation list (non-humanoid characters in one long take, fine-detail artifacts, temporal drift without pins) matches what you should expect when you stress-test with your footage.
Closed app versus open weights
The Viggle app is the supported path when you have no GPU farm. Open weights exist so studios can keep raw projects on prem, wire custom guardrails, and batch remakes that would be awkward in a consumer UI. You trade convenience for ops work: ffmpeg versions, worker queues, and license compliance on every shipped clip.
Closed video APIs from large labs still win on zero-setup demos, but they rarely publish rank-256 LoRAs, Comfy int8 graphs, and an MCP driver in one card. That combination is why Hugging Face trending picked up Remake despite a heavy base download. Teams evaluating build-versus-buy should price GPU hours, legal review of MiniMax terms, storage, and moderation of agent-generated outputs, not only per-second API fees.
Try it this week: a minimal checklist
- Rights: confirm you can alter the source video under contract or license.
- Disk: budget ~150 GB for selective MiniMax-H3 pulls plus LoRA files; do not
git clonethe full LFS tree unless you mean it. - Smoke test: run
examples/demo.shbefore you customize prompts. - Agent path: install MCP server and workers; start with the bundled White House Funk example before production footage.
- Disclosure: add on-screen or description labels; keep painted reference frames away from non-consenting faces and minors.