The Same Video, Built Twice

Two members of my community left comments under a guide I published. Same message, different words: nice studio, but have you tried the other tool? One of them asked for a comparison outright.

Fair. I run a weekly Q&A live that gets cut into fourteen YouTube clips. Every clip needs the same finishing layer: captions timed to the word, a question banner, animated visuals, a branded outro. At two uploads a day, the tool that builds that layer matters more than my opinion about it.

So I ran the test. One storyboard, written down to the second. Two tools. Same footage, same audio, same word timestamps. An agent built both versions while I did other work. Then I scored them.

The Brief Both Tools Got

The storyboard was not a softball. It demanded a circular picture-in-picture of an animated AI orb that asks the question, then slides off screen. A question banner that holds until the exact word the answer starts on. Five visualization beats triggered by specific words: a line chart that draws itself while I say "compounding", a progress bar that drains on the word "disappears", punch text, a building bullet list, a closing kicker. Word-timed captions with the current word highlighted. A branded outro card. Total runtime, 78.7 seconds.

Both tools got the identical spec file. Timings were law. Each tool's own motion system decided how the moves should feel.

The Two Tools

Remotion is the established name. I published a guide on it, and that guide is what the comments landed on. That one shows the setup. This one is what happened when we raced it.

HyperFrames is the newcomer. Its bet is different: the repo ships with skill files that teach an agent motion design doctrine. Transition grammar, caption compositing, cascade timing. Your agent reads the rules, then builds the video.

The Scorecard

Seven criteria. Each scored out of ten, on evidence from the test, not vibes.

HyperFrames wins. Here is where each number comes from.

Motion quality was almost a tie. Frame by frame, the two outputs are hard to tell apart. Both nailed the orb intro, the banner timing, the graph, the bullets. In motion, HyperFrames reads slightly smoother, and its eases carry meaning: the compounding curve accelerates the way compounding should. Half a point of difference. If this were the whole test, you could pick either.

Render speed was not close. HyperFrames rendered the 78-second video in 121 seconds, every time. Remotion took 298 seconds on a clean pass and 836 seconds when the machine was under load. Same video, same hardware. At fourteen clips a week, that gap is the difference between half an hour of rendering and three hours of it.

The iteration loop decides daily use. Both tools have a live preview with roughly one-second feedback. The difference shows after the preview. HyperFrames keeps every timing in one config block, and it can spit out a pixel-faithful frame from any point of the timeline in about 20 seconds, so you verify a fix without paying for a render. With Remotion, the final check is always a full render. Five to fifteen minutes to confirm a caption moved 50 pixels.

Hands-off reliability is where the test got honest. The point of an agent-built pipeline is that it runs while you do something else. The HyperFrames build went brief to finished file with zero intervention, including its own frame-level checks at the end. The Remotion build wrote a complete, correct composition, then stalled before rendering it. I had to finish the render by hand. One data point, not a verdict on the framework. But the test was "how far does it go without me", and one tool went all the way.

Agent intelligence is the widest gap and the most interesting one. My storyboard had a bug. I wrote that the answer footage starts at 7.8 seconds. The real cut in the source was at 9.8 seconds. Follow my spec literally and the speaker vanishes for two seconds, replaced by a leftover title card.

The HyperFrames agent did not follow it literally. It bisected the source frames, found the true cut, and hid the footage swap inside a push transition using a J-cut: the answer audio starts over the intro shot, and the video catches up two seconds later, invisibly. It documented the deviation and kept every other timing exact. That is not rendering. That is editing judgment. The Remotion agent handled the same trap, to be fair, which is why it scores a 7 and not less. But the doctrine files in the HyperFrames repo gave its agent sharper instincts to work with.

Ecosystem maturity goes to Remotion, clearly. Years of production use, a huge community, answers for every edge case. HyperFrames is at version 0.7 and its lint still throws advisory warnings on dense caption tracks. If you need battle-tested today and want a human in the loop anyway, Remotion remains the safe pick.

Flexibility ceiling also goes to Remotion. It is React all the way down. If you can code it, you can render it. HyperFrames trades a slice of that ceiling for structure an agent can follow reliably. For my use case that trade pays. For an interactive data-driven video product, it might not.

What Is HyperFrames?

HyperFrames is an open-source framework from HeyGen that turns HTML compositions into rendered video, built so AI agents can do the composing. You describe the video, the agent writes a declarative HTML timeline with GSAP animation, and the renderer outputs a standard MP4. The repo ships with motion-design skill files that teach the agent transitions, captions, and pacing rules, which is the part that makes agent-built output look designed instead of generated.

Set It Up

Three steps, about ten minutes.

Clone the repo and install the package. git clone https://github.com/heygen-com/hyperframes, then npm install hyperframes in your working folder.

Run npx hyperframes doctor to check the environment. The optional extras, like TTS and background music, can all fail. Rendering still works.

Then give your agent a brief, whether that is Claude Code, Codex, or any agent CLI. Point it at the repo's skill files and your footage. Ask for a 20-second test cut before a full video. Set HYPERFRAMES_NO_TELEMETRY=1 if you want the render fully local, which is how I run it.

Done. The first render is the tutorial.

Honest Limits Before You Switch

One, this is one test on one machine, an M-series Mac mini, with one storyboard. Your footage and your machine will move individual numbers. I do not expect the ordering to flip, but treat the scores as my weighting, not physics.

Two, neither tool does partial renders. Change one caption and you re-render the full timeline. HyperFrames just makes that tax five times cheaper.

Three, the reliability score contains luck in both directions. Agents are not deterministic. Run the same race tomorrow and Remotion's lane might finish clean.

Four, version 0.7 means things will change under you. Pin your version for production work.

Five, if your team already knows Remotion and ships with it daily, the ecosystem score alone may outweigh the speed gap. Switching costs are real costs.

Run Your Own Race

Do not take my scorecard. Take my method.

Pick one finished video you already have. Write its finishing layer down as a storyboard with timestamps: what appears, on which word, for how long. Give that identical brief to your agent twice, once per tool, and compare what comes back with your own eyes and your own criteria.

If you only do one thing this week: write the storyboard for one clip and hand it to an agent. If neither output beats what you do by hand, you spent one brief and two renders finding out. Mine came back better than the hand version, and now the whole layer runs without me.