edenfunf/reelmimic: a local animation pipeline where Claude Code or Codex is the runtime

The agent is the runtime, not an API you call

The repository description says it plainly: show it a video you love, get a new video in the same style, and an AI crew of Claude Code or Codex plans, builds and reviews it with you. The README makes the dependency concrete by stating that the whole thing runs on your own computer with your own Claude Code or Codex, and that all the work counts toward that account's usage.

That is an unusual and somewhat bracing design for a 1,503-star project with 177 forks. There is no model endpoint of its own, no per-render billing page and no hosted queue. What there is, in the repository tree, is a mix of runtime shapes: an `app/` folder, a `projects/` folder, a `docs/` folder with assets, a `requirements.txt` for the Python half, `.claude/` for Claude Code skills, `skills-lock.json`, and four launcher scripts split across platforms. Both agent ecosystems are supported in parallel and both have their own instruction file, with `CLAUDE.md` for one and `AGENTS.md` for the other.

The practical implication is that ReelMimic cannot be installed without those two tools already logged in. The getting-started requirements are Node.js 22.18 or newer, Python 3.10 or newer, FFmpeg, Chrome, and a logged-in Claude Code or Codex CLI. Chrome and FFmpeg are there for headless capture and frame handling, which is a reminder that this is a rendering pipeline, not a chatbot.

Seven drawing engines, and an admission about five of them

The engine list is the heart of the project and the README annotates it with candour that is worth quoting rather than paraphrasing. There are seven: vector and motion graphics built on HyperFrames, hand-painted watercolor built on painted-animation, plus crayon picture book, pixel art, paper cut-out stop-motion, whiteboard doodle and anime cel.

Then comes the sentence that tells you how to actually use this. The README says the newer five are young and have had less real-world use than the first two, and that when a reference video does not match a known style, the tool uses the closest engine and writes up a proposal for a new style. Almost no project documentation tells you which of its own backends to avoid. This one does, and it changes the reading of the demo gallery: the three showcase videos are all hand-painted or comic styles, which sits in the mature half of the list rather than the experimental half.

There is a related open design decision about styles. A new style is a Markdown file, so a person rather than a coder can write one, and the roadmap lists saving a newly discovered style from the web app so the next similar reference matches it directly. Between the two mature engines and the Markdown style files, this is the most extensible part of the project: the engines are fixed, but the style vocabulary above them is meant to be user-extensible. `LICENSES/` and `THIRD_PARTY_NOTICES.md` at the root are the right accompaniment to embedding third-party renderers, and their presence is a small sign of care that is easy to miss.

Up to six agents, and nobody grades their own work

The production loop is the part that distinguishes this from a single-shot generation script. The README says up to six agents work on different parts of the video at the same time, and that every finished shot is handed to a new agent for review so that nobody grades their own work. Fixes require proof: each one arrives with before and after screenshots and the reviewer checks them.

That is a sensible design for an agent pipeline, and it is worth being clear about what it costs. A 30 to 60 second video usually takes one to three and a half hours after you approve the plan, depending on length and look, and the README attributes the slowest engines to watercolor and crayon because every frame is painted with brushes. On top of that, every agent turn runs through your own subscription, and the README says a limit hit pauses the job so it can pick up where it stopped.

Observability is unusually thorough for a project like this. You can see what each agent is thinking, what it ran and which frames it looked at, with the full log available, and finished videos accept timestamped comments so you can scrub to any second, write a note and send them all at once. The Production line tab shows where each character and each part of the video stands, with the review screenshots inline. For a long asynchronous job that you are paying for by the hour, being able to reconstruct what happened at a given second is not a luxury.

The analysis stage behind all this is where the Python dependencies come in. The `requirements.txt` file covers numpy, opencv-python, scenedetect, librosa, Pillow and yt-dlp, with faster-whisper listed as optional for automatic lyrics timing against your own audio and opencc-python-reimplemented for Chinese conversion. Shot length, BPM, transitions, colors, framing and camera movement are all extracted before any drawing happens.

Install scripts, a doctor check, and secrets outside the repository

Getting started is two commands after the clone, with Windows equivalents shipped as double-clickable batch files:

git clone https://github.com/edenfunf/reelmimic.git && cd reelmimic
./install.sh      # on Windows, double-click install.bat
./start.sh        # on Windows, double-click start.bat

The service then listens on port 4318. The README points out that Claude Code picks up the skills in the repository on its own and that Codex reads `AGENTS.md`, so there is no separate agent configuration step. That claim is checkable in the tree, since `.claude/` and `skills-lock.json` are both present.

The install script also checks the environment, and the same check can be rerun at any time:

cd app && npm run doctor

Given the dependency list, that doctor command is more than a convenience. FFmpeg, Chrome, Node, Python and a logged-in agent binary all have to line up before anything renders, and a pipeline that fails at the compositing stage after two hours of agent work is an expensive place to discover a missing binary.

Secrets are handled in the way you would want. API keys and a few tool paths go into `~/.reelmimic/secrets.json`, which lives outside the repository so it cannot be committed, and `secrets.example.json` documents the shape. The keys include `YATING_KEY` for Taiwanese Mandarin narration voices, optional `PIXABAY_KEY` and `FREESOUND_KEY` for assets you are licensed to use, with Openverse noted as working without a key, and a set of path overrides for `FFMPEG_DIR`, `CHROME_PATH`, `CODEX_BIN` and `PYTHON`.

The sandbox default is the line to read twice

One settings entry deserves more attention than any other. The table lists `CODEX_SANDBOX`, described as the Codex sandbox mode, with a default of `danger-full-access`, compared in the README to Claude Code with Bash allowed.

That is a defensible default in context. ReelMimic runs a multi-agent pipeline that installs packages, drives a headless browser, renders frames with FFmpeg, writes project files and runs yt-dlp against URLs you supply. A workspace-write sandbox would break much of that. The problem is not the choice, it is that the most consequential setting in the project is one table row in a README rather than a decision the tool asks you to make.

The practical risk is specific. The agents write to disk, execute subprocesses, and can read anything the account can read, across a project that fetches and analyzes media you did not create. yt-dlp in the dependency list is a network fetcher pointed at user-supplied links. None of that is dangerous in the way a malicious package is dangerous, but it does mean the blast radius of a prompt or a bad instruction from a generated style file is the whole machine rather than a scratch directory.

So if you adopt this, set the sandbox mode explicitly rather than inheriting it, and read it as the same decision you would make before running any agent with Bash access. The setting is there and documented, which is more than most projects offer. What it lacks is a prompt.

A second scoping note sits in the same section of the README: it makes animation, not live-action footage of real people. For a style-transfer tool that takes arbitrary reference video, that boundary is the one to keep in view.

No releases, three READMEs, and a Windows-weighted support claim

The repository has no releases at all. There is nothing tagged and nothing published, so the install path is the git clone above, which means you are tracking `main` and the last push on 2026-10-06 is the newest version available. With 31 open issues against 1,503 stars, that is a busy repository, and for a tool that renders multi-hour jobs it is a reasonable thing to want tagged builds of.

Documentation, by contrast, is well resourced. There are three README translations, English, 繁體中文 and 简体中文, switchable from the top right of the app, plus a `CONTRIBUTING.md` and a `docs/` folder carrying the logo, the demo GIFs and the flow and home screenshots in light and dark variants. The prose is unusually direct about limits: it says macOS and Linux should work but have had less testing, with Windows being the tested platform, and it lists faster watercolor rendering as an open item rather than pretending the slow path is finished.

The three demo clips are annotated with what they cost, one hand-painted music video at 58 seconds, another at 63, and a 30-second narrated comic, each with a note that previews are silent with lyrics cropped out. Small detail, but it is the difference between a project showing you what it made and a project showing you what it made at a size you will actually be able to wait for.

Putting it together, the shape of this project is: an opinionated pipeline that delegates execution to a general-purpose coding agent, keeps the rendering engines narrow and fixed, makes the style layer user-extensible, and tells you plainly which parts are young. That is a coherent bet. The two things to check before a first render are the sandbox mode and the doctor output.

Editorial conclusion

reelmimic is not a video model and does not pretend to be one. It is a JavaScript web app on port 4318 with a Python analysis stage, seven pluggable 2D rendering engines, and a multi-agent review loop that runs inside your own Claude Code or Codex subscription. That design puts the cost where you can see it, in your own plan's usage and in one to three and a half hours of wall clock time for a short video, and it puts the permissions where you should check them, since the documented sandbox default is danger-full-access. The README is unusually candid about which two engines have seen real use. Start with the vector or watercolor engine rather than the young ones, run the doctor check before your first render, and read the sandbox setting before you approve a plan.

Frequently asked questions

Official sources

1. edenfunf/reelmimic on GitHub
2. Issues
3. License: MIT
4. README