DEV Community: Cybiqon

We turned web pages into Snake mazes. The hard part was finding the empty space.

Cybiqon — Sun, 01 Nov 2026 04:30:02 +0000

On 28 July we wrote down an idea: click a button and the page you're reading becomes a Snake level. The snake moves through the empty space between paragraphs. The words are walls.

It sat in a notes file for 49 days. On 15 September we built it, and on 4 October Page Arcade went live on the Chrome Web Store. It now has eight games, and version 1.1.0 shipped on 22 October.

The games turned out to be the easy part. The hard part was one question the notes file answered wrongly: where on a web page is the empty space? A person can tell at a glance. Code has to decide 12 pixels at a time, on a page it has never seen, and it has to be right. If it marks a word as empty, the snake slides through text. If it marks empty space as a wall, the snake dies on nothing, and the player blames the game.

This post covers how we answered that question: the screenshot-first freeze, the grid, the rule that lets a snake cross a 1-pixel line but not a word, and the bug report from the owner dying on ChatGPT next to an icon they never touched. It also covers the part that doesn't flatter us: this product broke our own rule, and it still earns nothing.

TL;DR

The page is never edited. It's photographed, and the game is played on the photograph. The extension takes a PNG screenshot before it injects anything, then reads the page's layout, then lays one overlay on top. Press Esc and the page is exactly as it was.
"Empty" is decided by two tests that cover each other's blind spots. A 12-pixel cell is a wall if its pixels vary by more than 24 in any colour channel, or if the browser says text or media sits there. The pixel test sees what's drawn. The layout test catches very faint text the pixel test would pass.
Thin lines had to become passable, and that took a classifier. Before it, a 1-pixel <hr> walled off two rows of cells and split the board in half. After it, there were 0 deaths in 1,456 scripted crossings of lines and borders at three zoom levels. A run of underscores still blocks the snake, because underscores are content.
The best bug report was a death on ChatGPT. Invisible button boxes, hidden screen-reader labels and text boxes grazing a cell by one pixel were all being treated as walls. On a ChatGPT-like test page, walls with nothing drawn in them went from 124 of 472 to 0 of 345.
A random empty cell is not reachable. The original notes said it was. The free space on a page is a set of islands, so the game keeps the largest island, joins the second one with a portal when it is big enough, and refuses to start on pages with fewer than 80 free cells.
It asks for three permissions and no site access. activeTab, granted by your click, is enough to take the screenshot and inject the game. The extension does nothing on any page until you ask it to.

Page Arcade, in one paragraph

Page Arcade is a Chrome extension. Click its icon, or press Alt+Shift+P, and the page you're on freezes and becomes a game level. There are eight games.

Snake lives in the page's empty space; the edges wrap, and thin lines can be crossed.
Word Blaster: the page's own words fall in waves and you shoot them from a rocket.
Type Storm: you type the falling words to destroy them.
Brickout: every word on the screen is a brick.
Whack-a-Word: click the words that pop out of the page.
Page Roller: roll the page up, smallest words first.
Gravity Crumble: knock words loose and let the page collapse.
Page Chomp: eat the dots in the empty space while four ghosts chase you.

There is no account. Scores, XP, 23 achievements and 18 skins live in your browser. Per-site leaderboards and share links are opt-in.

The idea is old. That's the point.

We weren't the first to play on web pages, and the research file we wrote on day one says so.

Kick Ass (2010) put an Asteroids ship on any page and let you shoot the elements.
Katamari Hack (2011) rolled a page's words up into a growing ball.
Google Gravity (2009) dropped the Google homepage into a physics engine.
PlayAnyPage, a bookmarklet from April 2026, has Brickout and a Snake that lives in text. It's the closest thing to what we built.

What the hits had in common was instant play on the page you were already on. That set the bar. There's no level select and no loading screen: the game starts on whatever page you're reading. It also set the hard constraint. If the level is whatever page you happen to be on, the code has to understand pages it has never seen, and it gets one try.

Step one: freeze the page without touching it

The obvious approach is to inject a canvas over the live page and run the game on top of it. That fails in small ways. Carousels keep rotating. Videos keep playing. The page's own keyboard shortcuts fire when you press an arrow key. And if the game edits the page, removing words as they're shot for example, there's no clean way back.

So the page is never edited. It's photographed, and the photograph is played on.

Capture first. When you click, the background worker calls chrome.tabs.captureVisibleTab as a PNG, before anything is injected, so the image is the page and not our overlay. It has to be PNG: the free-space test compares exact pixel values, and JPEG noise looks like content.
Read the layout. A content script asks the browser where every line of text and every image, video, canvas, SVG and form field is drawn. This happens before the overlay exists, otherwise every lookup would hit the overlay itself.
Mount one overlay. It's a single custom element on <html>, not <body>, because a transform on <body> would break position: fixed. It uses a closed shadow root and the maximum z-index, and holds two canvases: the backdrop (the screenshot, redrawn only when a word is destroyed) and the game layer, redrawn every frame.
Freeze, don't disable. Keys are swallowed at the capture phase, but Ctrl, Alt and Meta shortcuts and the F-keys still pass through. Playing videos and audio are paused. Scrolling is pinned to the current position rather than switched off: overflow: hidden would remove the scrollbar, reflow the page and make every measurement we had just taken wrong.

Press Esc and the overlay goes, the listeners go, the scroll position comes back and paused media resumes. The page never knew.

Destroyed words are painted into a copy of the screenshot. The original bitmap is never drawn on, so Retry can restore the page exactly.

One measurement trap: the screenshot's scale comes from screenshot.width / innerWidth, not from devicePixelRatio. Under browser zoom and Windows display scaling, the two disagree, and the size of the captured image is the only number that is always right.

Diagram: What happens between the click and the first move. Nothing touches the page itself. See it in the original post.

Step two: what counts as empty

The grid cuts the overlay into 12 CSS-pixel cells, centred so the leftover strip is split between both edges. Each cell has to be classified as free or wall, and there are two ways to be wrong.

The pixel test. For every cell, take its screenshot pixels and measure the spread (max − min) in each colour channel. If any channel varies by more than 24, something is drawn there, and the cell is a wall. Uniform means empty, whatever the colour. Dark themes, tinted panels and gentle gradients all count as space. Text, icons, borders, images and drawings don't. Cell boundaries round outwards, so a line sitting exactly on a cell edge blocks both neighbours. A free cell that is really a border is the worse of the two mistakes.

The layout test. The browser knows exactly where every line of text is drawn: Range.getClientRects() returns a rectangle per line. It also knows the box of every image, video, canvas, SVG, iframe and form field. A cell those rectangles overlap is a wall. This catches what the pixel test misses: very low-contrast text that varies by less than 24 against its background.

Neither test is enough alone. The pixel test can't see grey-on-grey text. The layout test can't see a background image with text baked into it. Together they mostly agree with what a person would call empty.

On a Wikipedia article at 1,366 pixels wide, this produces something you might not expect: the article itself is solid wall. 12-pixel cells don't fit between lines of body text, so the snake lives in the gutters, the margins and the gaps around headings. That turned out to be the right game. The page's layout becomes a maze, and every site's maze is different.

Step three: the snake must not die on a line

The first version had a bug the owner found in minutes. The snake died on <hr> dividers and thin borders.

Under the rules above that was correct: a 1-pixel line makes a cell non-uniform, so it's a wall. Because boundaries round outwards, a 1-pixel rule actually walled off two rows of cells. On a page with a divider across the middle, the board was cut in half.

A person sees a thin line as decoration, not as a wall. Teaching the grid the same thing took a classifier, and most of the work was in what it must not free.

A wall cell becomes a passable line cell only if all of these hold:

one background colour covers at least 60% of the cell;
every "ink" pixel lies in at most one horizontal and one vertical band, each at most 3 CSS pixels thick (plus anti-aliasing), so dashed and dotted lines still count;
the band touches a cell edge, because a hyphen in the middle of a cell isn't a border;
the band is a single colour.

The layout data adds hints. <hr> elements and element borders of 3 pixels or less loosen the rules where they overlap, so dashed borders whose dashes stop short of the cell edge still pass. Hints only loosen the rules; they never free a cell on their own. A final pass frees rounded corners whose neighbours on both sides are lines.

Text is never a line. An underscore, a row of dashes or an icon's straight stroke looks exactly like a thin border to a pixel classifier. So any cell where the browser says text, an icon or a button is drawn is ruled out before the classifier runs. That single rule removed the worst class of bug: snakes sliding through ________ in a form.

The evidence is in the tests: 16+ classifier cases, including 1-pixel and 3-pixel lines (free), 4-pixel lines (wall), 2× scale, dashed, dotted, a hyphen, a stray pixel, two colours, anti-aliasing, a shadow, text over a line and a dark theme. A headless test page full of <hr>s, bordered divs and a table was crossed 1,456 times by a scripted snake at 1×, 1.25× and 2× zoom, with 0 deaths. On one Wikipedia article, 536 cells that used to be walls became crossable lines.

Press G during Snake and the game paints its own reading of the page: walls in red, line cells in cyan. It's a debug view we left in, because it's also the fastest way to tell whether a death was fair.

The death on ChatGPT

On 17 September the owner died playing Snake on ChatGPT, next to a copy icon they hadn't touched. They sent a screenshot of the G view. Red cells covered empty space.

There were four causes. All of them were walls made of nothing:

A button's box is bigger than its icon. A copy button is a 32-pixel box around a 20-pixel icon. Any cell the box touched by half a pixel became a wall, which put a band of invisible wall around every row of icons.
Text boxes grazing a cell. A text line's rectangle that clipped a 12-pixel cell by one or two pixels walled the whole cell.
Visually hidden text. Screen-reader labels and transparent tooltips are invisible, but they still have layout boxes. Three of them sat in ChatGPT's empty sidebar header, and each one was a wall.
Icons read as lines. Once icons stopped being box walls, their straight strokes started passing the line classifier. The share and regenerate icons showed up cyan.

The fixes:

A layout rectangle now counts only if it reaches at least 3 pixels into a cell on both axes.
Text rectangles lose their empty top 15% and bottom 10% before they're tested.
Icons, buttons and text are walls only if something is actually drawn in the cell, and they're never eligible to be lines.

We measured the result as the number of wall cells whose pixels are blank, on a local test page built to look like ChatGPT: a reply, a row of 32-pixel icon buttons, a composer, a hidden label and a transparent tooltip. Before: 124 of 472 walls had nothing drawn in them. After: 0 of 345, with 0 line cells inside any icon or button. On Wikipedia's Snake article the count went from 210 to 96. The 96 left are flat dark areas inside a photo, correctly walled by the image's box.

A game is fair when the player can see why they died. Every one of these bugs was a death the player couldn't see a reason for.

A random empty cell is not reachable

The original notes from July had one confident line in them: put food on any random free cell, and it's "guaranteed reachable."

It isn't. The free space on a web page isn't one space. Margins, gutters and paragraph gaps are islands, walled off from each other by text. Food in the left margin is unreachable from a snake in the right margin.

So the grid is flood-filled into labelled islands, 4-connected and never diagonally. Since Snake's edges wrap, the fill wraps too: a left margin and a right margin that meet at the screen edge become one island. Then:

The largest island is the arena. Food and power-ups only ever land on it, so everything on the board is reachable.
If the second-largest island has at least 30 cells, a pair of portals joins it to the arena.
With fewer than 80 free cells, or no straight run of 5, the game doesn't start. It tells you there isn't room and suggests scrolling to another part of the page.

We kept the wrong line in the notes file, with a pointer to the correction. The mistake is worth remembering: it sounded obvious, and it would have produced a game where food sometimes appears where you can't get to it.

Eight games, one grid

Once the grid existed, the other games came quickly, because each one is a different question asked of the same page:

Snake and Page Chomp use the free cells. Page Chomp's dots and ghosts live in the same islands Snake does, and the four ghosts chase with the classic arcade personalities: one targets you, one aims four cells ahead of you.
Word Blaster, Type Storm and Brickout use the text rectangles. Each word on the screen is a target or a brick at the exact position it was drawn. Word Blaster names its waves after the page's own section headings.
Page Roller and Gravity Crumble use the words as physical objects. Gravity Crumble is the only game that uses a physics library (Planck.js, a JavaScript port of Box2D). Everything else runs on our own small kit: a spatial hash, swept circle-against-box collisions and a Verlet rope.

There is one runtime dependency, no framework and no audio files. The sound effects are synthesised with WebAudio. Screen shake, hit-stop (a 30 ms pause on a kill, 200 ms on death) and a pool of 2,000 particles in typed arrays are shared across the games. In headless Chromium at 2× on Wikipedia and MDN, median and 95th-percentile frame times were both 16.7 ms, a steady 60 fps.

Reduced motion is a setting that follows the operating system's preference, and it turns the shake off. Screen flashes are capped at one per 340 ms, which keeps them under the three-per-second limit in WCAG 2.3.1.

Permissions: three, and no site access

The extension asks for activeTab, scripting and storage. There is no host permission and no content script declared in the manifest, so it installs without the "read and change all your data on all websites" warning and does nothing on any page until you click.

activeTab is the whole trick. Clicking the icon, or pressing the keyboard shortcut, grants temporary access to that one tab. That's enough to screenshot it and inject the game, and it ends when you leave.

The store build adds one more host permission, api.cybiqon.in, for leaderboards and share links. Both are off until a player turns them on. Leaderboards store the site's hostname, the game, the score, a nickname and a random player ID. Never the page or its address beyond the hostname. Share links keep a picture of the wrecked page for 30 days. The full list is in the privacy policy.

One packaging detail: the content script is built as a single self-contained file. The default build tool would have split it into a chunk loaded on demand, and loading that chunk into the page needs a host permission we deliberately don't ask for.

The part that doesn't flatter us

Our company has a rule, written at the top of the file every session reads: no new product until there is revenue. The failure mode it guards against is starting things.

Page Arcade broke it. It was the fifth time. The decision is recorded in the product's own notes, with the date and the fact that total earnings that day were $0.03. The scope was supposed to be a local prototype: no store listing, no backend.

It grew in four steps:

Day one was about 2,100 lines: two games.
Later that same day, 5,100 lines and three games.
Two days later, eight games, achievements, skins, a share card and a live backend for leaderboards.

Today it's 16,809 lines of source and 5,323 of tests. Every expansion was chosen, not drifted into. Each one still made the product bigger, and none of them made it earn.

It earns ₹0. There are no ads, no purchases and no plan to add either. The honest case for it is that it's the most shareable thing we've built: it turns any page into a screenshot worth sending. It's also a working demonstration of something we sell: reading a web page the way a person does, from its pixels and its structure together. That's the same skill behind scraping a Google Maps result in MapWit or capturing real footage for our videos.

It still has no kill criterion, a date or a number at which we stop. That is the next decision about it, and it's overdue.

One more confession. On 22 September we added a cheat for playtesting: type iddqd on the menu and nothing costs a life. The note said to remove it before the store submission. On 4 October the owner decided to keep it. God-mode runs never post to the leaderboards, so it can't spoil anyone else's score.

What we'd tell someone building the same thing

Screenshot first, inject second. Every measurement depends on the page being still, and the only reliable way to keep it still is to stop reading the live page.
Use pixels and layout together. Either one alone is wrong in ways the other catches.
Decide which mistake is worse, then bias towards it. For us, a free cell that is really content is worse than a wall that is really empty. Then fix the walls that are really empty anyway, because players notice those.
Leave the debug view in. The G overlay turned a vague "I died for no reason" into a screenshot with the bug visible in it.
Measure with scripted play, not by eye. A scripted snake can cross the same line 1,456 times at three zoom levels; a person playing tests a handful. We did the same for our puzzle games, where eight bots played every level.

Page Arcade is free on the Chrome Web Store. Try it on the page you're reading.

FAQ

How do you turn a website into a game?

Page Arcade, a free Chrome extension, takes a screenshot of the page and asks the browser where every line of text and every image is drawn. It then lays a game over the frozen page. The page's empty space becomes Snake's playing field, and its words become bricks, targets and falling enemies. Pressing Esc removes the game and leaves the page exactly as it was.

How does Page Arcade decide where the empty space on a page is?

Page Arcade cuts the page into 12-pixel cells. A cell is a wall if its screenshot pixels vary by more than 24 in any colour channel, or if the browser reports text or media in it. Thin lines of 3 pixels or less, such as <hr> dividers and borders, are classified separately and can be crossed. Text, icons and buttons never can.

Does Page Arcade read or change my data on websites?

No. Page Arcade asks for activeTab, scripting and storage, with no host permission. It does nothing on a page until you click its icon or press Alt+Shift+P, and it never edits the page. Leaderboards and share links are opt-in, and they send only the site's hostname, your score and a nickname, or the share picture you chose to upload.

What games are in Page Arcade?

Page Arcade has eight games: Snake, Word Blaster, Type Storm, Brickout, Whack-a-Word, Page Roller, Gravity Crumble and Page Chomp. Version 1.1.0, released on 22 October 2026, added new modes, power-ups and bosses to Snake, Word Blaster, Type Storm and Brickout, plus a redesigned menu and HUD.

Is there a cheat code in Page Arcade?

Yes. Typing iddqd on the Page Arcade menu turns on god mode for the session, so nothing costs a life. It was added for playtesting and kept on purpose. God-mode runs still earn local records and XP, but they never post to the leaderboards.

Sources

chrome.tabs.captureVisibleTab — Chrome for Developers
The activeTab permission — Chrome for Developers
Range.getClientRects() — MDN
Kick Ass — the 2010 Asteroids-on-any-page bookmarklet
Katamari Hack — rolling up a page's words, 2011
Google Gravity — the Google homepage in a physics engine
PlayAnyPage — a 2026 bookmarklet with Brickout and Snake on any page
ZType — the typing shooter Type Storm follows
Planck.js — the 2D physics library behind Gravity Crumble
Understanding WCAG 2.3.1: Three Flashes or Below Threshold — W3C
Juicing Your Cameras With Math — Squirrel Eiserloh, GDC 2016, on trauma-based screen shake

Originally published on cybiqon.in. Cybiqon is a small Indian software studio: websites, apps and AI automation for growing businesses. See what we build.

Twelve videos in four days. Nobody picked up a camera.

Cybiqon — Sun, 25 Oct 2026 04:30:02 +0000

Updated on 12 October 2026. The studio is now open source: cybiqon-ai/faceless-video-studio (MIT), with a step-by-step setup guide. It has moved on since this post was written: 38 gates (a new one, B18, fails a Short whose bottom 40% is empty), 22 look families instead of 15, and two more render engines alongside HyperFrames — the vendored animate styles and Manim. The figures below are as of 11 October.

On 8 October our company changed what it does with its evenings. The products were built and almost nobody knew they existed, so from that day the focus became content: a video every day for YouTube and Instagram. There was one condition. I would not film anything. No camera, no microphone session, no editing timeline.

Four days later there are twelve finished videos. Eight came out of the daily studio: teaching Shorts, two seven-minute long-forms, product promos. Four are explainers of our own blog posts, now on YouTube. All twelve are narrated in my voice, which I recorded once. Every frame is HTML and GSAP animation rendered to MP4 by HyperFrames. The narration is a HeyGen clone. A Claude Code agent does the rest — it picks the topic, researches it, writes and lints the script, voices it, builds the frames with parallel sub-agents, checks its own work, renders, and sends the MP4 and a post kit to my Telegram before I wake up.

That is the flattering version. The honest one is that my first review said "too fast, too much content", the fourth said the script "considers the viewer as an expert, which is wrong", and in between I told the agent its videos looked so alike that "it will soon be noticed as AI generated". This post is the whole machine: what it is made of, every complaint and the gate it turned into, the voice clone, what it actually costs to the cent, and how to set it up on your own computer.

TL;DR

12 finished videos in 4 days, with no filming. 8 from the daily studio and 4 blog explainers on YouTube, between 8 and 11 October 2026, across 34 commits. HyperFrames renders the frames locally; HeyGen supplies the voice clone and music. No avatars and no cloud rendering.
The voice cost $8.20 in total. We loaded $15 into HeyGen's pay-as-you-go API wallet; on 11 October the API reported $6.80 left. Measured on the clone, a minute of narration costs about $0.14. The agent's own runs cost far more: about $18.35 for one 85-second Short and about $26 for a seven-minute long-form plus its companion Short.
37 pass/fail gates, and most of them exist because something went wrong. The pace gate came from "too fast", the 12-year-old gates from "too expert", the variety gate from "looked alike", the hook gate from "the hook doesn't make sense", and the newest gate from words that were being cut in half.
The voice was the hardest part. At HeyGen speed 0.9 the clone spoke about 3 words a second against our 2.0 target, and its timestamps run about 0.2 s late, which clipped the start off a third of all sentences. The fix is one take per sentence at 0.75, trimmed on the actual sound.
A render takes 2.5 to 19.5 minutes on a 4-CPU machine. The longest, 12,722 frames for a 7-minute video, took 1,168 seconds. Every fix after rendering costs a full render again.
We did not track cost per video. Every ledger entry has cost_usd: null. That is the first thing we would do differently.

What HyperFrames and HeyGen each do

These two tools get confused, partly because HyperFrames is published by HeyGen. They do completely different jobs here.

HyperFrames is the renderer. Its own description is "an open-source framework for turning HTML, CSS, media, and seekable animations into deterministic MP4 videos", under the Apache 2.0 licence. A video is an HTML file. Each element declares when it appears with data-* attributes, animation runs on a GSAP timeline that the renderer can seek to any frame, and a headless Chrome captures every frame before FFmpeg encodes them. Because the page is plain HTML, an agent that can write a web page can write a video, and because rendering is deterministic, the same file gives the same MP4 every time. We pinned versions 0.8.141 to 0.8.145 over the four days, one per project, and render everything on our own machine.

HyperFrames also ships agent skills — the README counts 21 — that teach a coding agent how to build compositions: a router skill, the composition contract, animation rules, a CLI skill and workflow skills such as faceless-explainer and product-launch-video. We installed them on 20 September and use them under our own skill, described below.

HeyGen is the voice. HeyGen is best known for AI avatars, and we use none of that. We use three things, all through its API:

An instant voice clone of me, made once and verified on 8 October with word timings. Every video uses the same voice; that is part of the brand.
Text-to-speech with that clone, which returns a WAV file and per-word timestamps.
Background music retrieval, which costs nothing per call in our tests, and once returned nothing at all.

Everything else is ours: the research, the script, the design system, the frames, the checks and the delivery.

The pipeline: from a topic to an MP4 without a camera

The studio is a Claude Code skill called video-studio, run from cron with claude -p "/video-studio daily". Every stage writes its output to disk inside the video's folder, so a run that dies at 3 a.m. is resumed by the next night's run instead of being thrown away.

Diagram: The eight stages of one studio run. The two shaded stages are the gates; no money is spent on voice until gate A passes. See it in the original post.

Pick. ledger.py today returns the delivery date, the day's pillar, the format and what was made recently. A topic I have scheduled on our content planner takes priority. Otherwise the agent searches the web for what is trending or confusing that week. ledger.py check refuses a reused slug, or any topic whose words overlap 50% or more with anything from the last 30 days.
Research dossier. Every fact gets a numbered source URL in research/sources.md. For a teaching video the solution is written and run first, and the output shown on screen is pasted from the real run. The skill's rule: "Nothing goes on screen that is not in this folder."
Plan. PLAN.md holds three hooks of different types, each scored out of 12; the story; a beat-by-beat storyboard; a script with a word budget; and a look. The agent picks the look after researching two or three reference creators, and the ledger refuses one used in any of the last three videos.
Gate A. The script must pass a linter and three separate reviewer agents (described below) before a single second of audio is generated. Voice is the only step that costs money per attempt, so it waits.
Voice. voice_build.py voices the script one sentence at a time with my clone, trims each take on its real sound, and writes a manifest of every file's hash.
Frames. One general-purpose sub-agent per beat builds that beat's HTML in parallel; a long-form goes in waves of eight. A HyperFrames helper assembles them into one index.html.
Gate B. npx hyperframes check --strict, then snapshots at the middle of every beat. The agent opens the snapshots as images and checks them against the rubric. After the render, a separate judge agent looks at frames decoded from the final MP4. At most two fix loops.
Render and deliver. npx hyperframes render --quality high, then FFmpeg's loudnorm brings the audio to −14 LUFS. deliver.py checks the post kit and sends the video to Telegram with three titles, a YouTube description, an Instagram caption, hashtags, a pinned comment and the sources. It prints one line — Rendered: <slug> <seconds> <MB> msg <id> — and that line is the only proof of success the cron trusts.

The studio never posts. YouTube's API keeps uploads private until an app passes Google's audit, and Meta offers us no posting route, so I publish by hand from the Telegram message. That is why the most honest measure of the studio is posted divided by made, not made.

Three tracks a day

Cron (IST)	Track	Ceiling
23:00 daily	itspyguru: teaching Short, or a 16:9 long-form on Wednesday and Sunday	3 h / $25; long-form nights 7 h / $60
14:00 daily	blog: an explainer of that day's post on our AI blog	2 h / $20
16:30 Mon, Thu, Sat	promo: a Cybiqon product or service	2.5 h / $25

The weekly rotation is fixed in code: an AI term on Monday, Python on Tuesday, a long-form on a trending AI tool on Wednesday, a small build on Thursday, the week's tech story on Friday, an AI term or Python on Saturday, and a system-design long-form on Sunday. Both long-form days also get a vertical companion Short cut from the same research.

The Claude Code skill behind it

The skill is open source at cybiqon-ai/faceless-video-studio; when this post was written it lived only in our company repository. Its SKILL.md was 404 lines and has seven modes: daily, promo, blog, plan <topic>, build <slug>, revise <slug> "<feedback>" and setup. revise takes one sentence of my feedback and rebuilds only what that sentence touches.

Part	What is in it
`references/`	The quality rubric; 15 look families; the pillars; a prompt library; `jargon.txt` (the terms a beginner wouldn't know)
`references/craft/`	Nine researched craft notes: hooks, retention and story, script voice, teaching formats, visual design, product promos, platform specs, recording and lighting
`templates/`	`PLAN.md` and the `BRIEF.md` handed to the HyperFrames workflow
`assets/`	The brand core, the logo, vendored fonts (Plus Jakarta Sans, JetBrains Mono) and four caption skins
`scripts/`	Six Python tools and their unit tests

The six scripts are the deterministic half of the system: the parts where we did not want a model's judgement.

Script	Job
`ledger.py`	Today's pillar and format, the no-repeat check, the look-variety check, marking a video posted
`planner.py`	Reads the topic I scheduled; "never raises: a planner outage must not stop a video"
`script_lint.py`	Gate A18: sentence length, reading grade, number density, jargon, idioms
`voice_build.py`	One HeyGen take per sentence, trimmed on sound, with a hash manifest; `--check` is gate B17
`gap_check.py`	Gate B16: no silence over 0.7 s between lines
`deliver.py`	Refuses delivery without the four PASS lines, the voice check and a `look` block, then sends to Telegram and writes the ledger

The craft notes are where the research went. They cite YouTube's own help pages on Shorts, Nielsen Norman Group on dark mode, a large study of edX lecture videos on how long people keep watching, 3Blue1Brown's FAQ, HeyGen's and ElevenLabs' voice-cloning guides, and awesome-opus5-5-videos, an MIT-licensed list of videos made with Claude together with the prompts their creators shared. We read that list on 10 October, and it gave us the prompt library, three new looks, two gates and the most useful single rule in the visual notes: simulate the thing, don't depict it.

Running an agent unattended, safely enough

The cron calls a wrapper, studio/run.sh, which comes down to this:

flock -n /tmp/cybiqon-video-studio.lock timeout "$LIMIT" claude -p "/video-studio $ARGS" \
  --permission-mode acceptEdits \
  --allowedTools "Read,Write,Edit,Glob,Grep,WebSearch,WebFetch,Skill,Task,TodoWrite,Bash" \
  --disallowedTools "Bash(git push:*),Bash(rm -rf:*),Bash(curl:*),Bash(wget:*),Bash(sudo:*),Bash(crontab:*),Bash(ssh:*),Bash(scp:*)" \
  --strict-mcp-config --mcp-config '{"mcpServers":{}}' \
  --max-budget-usd "$BUDGET"

Four decisions are packed into that command.

flock and timeout. Two agent sessions never overlap, and every run has a wall-clock ceiling. The long-form ceiling of seven hours still ends before the next scheduled job.
--max-budget-usd. Claude Code stops the run once its own estimate of API spend reaches the cap. The documentation is careful to say the estimate "can differ from your bill", and that spend can pass the cap, so leave headroom.
Bash allowed whole, with explicit denies. Our first unattended run used a per-command allowlist and stalled at cd hf && node …: a headless run cannot answer a permission prompt. Since python3 was already allowed, listing commands bought no safety, only fragility. So the shell is open, and pushing, downloading, sudo, ssh and rm -rf are refused. There is still no --dangerously-skip-permissions.
No MCP servers. The run reads the web and then runs code it wrote, because "code on screen is code that ran". The tool scope is the limit on what a poisoned web page could make it do.

Then the check. A cron that exits 0 tells you nothing — our company's rules say that exit code 0 "has already meant 'did nothing' for 33 consecutive nights" on another job. So run.sh counts: if this run's slice of the log has no Rendered: line, I get a Telegram alert with the reason, whatever the exit code says. It also spots a logged-out CLI and says so.

37 quality gates, and the failure behind each one

The rubric has 20 plan checks (A1–A20) and 17 build checks (B1–B17). "Each line is pass or fail; there is no partial credit." Thirty-two are hard, meaning a failure blocks the video (two of those apply only to teaching or long-form videos). Few of them were in the first version. Most were added on the day a video failed in that exact way.

Gate	Rule	Why it exists
A8	Narration at most 2.0 words a second, with a 0.4–0.8 s hold after a key reveal	The first Short, Two Sum: 97 words in 44 s. My verdict: "too fast, too much content"
A14	The viewer is fixed: "a smart 12-year-old who has used ChatGPT and never coded"	The temperature Short's script "considers the viewer as an expert"
A15	Every term defined in the same breath	That script had idioms and maths words, and 17 spoken numbers in 72 s
A16	Teach-back review: a fresh agent hears only the narration, a separate judge grades it	The first reviewer was told to play "a developer", and the planner graded its own pass
A18	`script_lint.py` passes: no sentence over 18 words, reading grade ≤ 7, ≤ 1 number per 10 s	The mechanical half of A14
A19	Expert accuracy review: simplified is fine, false is not	An outside review caught three simplifications in the temperature Short that had become untrue
A2, A20	The hook is the viewer's own question, proven on screen by 3 s; a cold-viewer agent must get it	"The hook doesn't make sense… I am noticing this in all videos"
B11	Real footage fills ≥ 80% of the frame for ≥ 50% of the runtime	"The actual visuals were limited to very small space on screen"
B13	A fresh agent must not call this video and the last three the same template	"The last two videos were quite similar"
B14	A judge reviews ≥ 6 frames decoded from the final MP4, not just browser snapshots	Snapshots are not the file: our rendered frame 0 once differed from every snapshot
B16	No silence over 0.7 s between voice lines	Padded frames left 3–5 s gaps in the first long-form
B17	Every word is heard: each voice line was made by `voice_build.py` and starts and ends on silence	A third of all sentences were losing their first ~0.2 s

The three reviewer gates are worth a closer look, because they are where we learned the most about using agents to check agents.

A16, the teach-back. A fresh sub-agent that has never seen the research, the plan or the storyboard gets only the narration and three "why" questions the planner wrote in advance. Its persona: "You are 12, smart and curious. You've used ChatGPT but never written code, and English is your second language." It explains back what it learned, answers the questions and lists every point where it would have asked "what's that?". A second, separate judge then sees the narration as well, so it can tell a real gap from a point the script already explains. The first version of this judge saw only the reviewer's notes. It kept failing points the script covered, every round of fixes added words, and a 355-word script grew to 482 without ever passing, although every teach-back had been correct. Now fixes may not grow a script past its length budget, and the planner may never overrule the judge.

A19, the expert. A beginner can understand something false. So a second fresh agent, playing "a senior ML engineer / Python core developer / systems engineer", flags only what is false, what plants a misconception, and causal claims that are wrong. Each flag comes with a replacement that is "just as simple and true".

A20, the cold viewer. A third agent gets only the first three seconds: the first two narration lines, the on-screen text and a description of what is visible. "You are scrolling Instagram Reels. You know nothing about this video." If it can't say who the video is for and what problem it is about, the hook is rewritten.

Then there is deliver.py, which refuses to send a video unless PLAN.md contains the literal lines A16: PASS (judge), A18: PASS, A19: PASS (expert) and A20: PASS (cold viewer). That is the difference between a rule and a gate. Gate A is text the agent reads; deliver.py is code that refuses.

Two things the logs show plainly. On the first long-form, the 12-year-old review "passed only on the third judge round"; the rubric says a second failure means splitting the topic, and the agent treated it as a wording fault instead. It wrote that down in the report: "That's a deviation." And on one Snackly revision, "the final-file review never formally passed": two judge rounds failed, the agent fixed every major point and checked the render frame by frame itself, but no third judge ran. Both were disclosed in the delivery, which is the rubric's rule — "Never deliver silently" — and both are why the gates keep tightening.

Cloning a voice with HeyGen: what it took

The voice is the part a viewer notices first and the part that went wrong most often.

The sample. HeyGen's own guide asks for "30–60 seconds of expressive speech with your phone close to your mouth"; its developer docs for instant clones say only the first three minutes of a recording are used, in MP3 or WAV, up to 100 MiB. ElevenLabs notes that more than two or three minutes gives little extra for an instant clone. Our skill's guidance splits the difference: record one continuous take of 90 to 120 seconds, then submit the best 60 to 90. The other rules come from the same guides. Use a quiet room, because the clone copies the room. Read more expressively than feels natural, because cloning flattens tone. Read the kind of script the clone will speak, in your natural accent, including the words where the accent shows. Our practice script, about 230 words, has a Two Sum walkthrough, an embeddings explanation, a line in Hinglish ("price kya hai?") and a run of numbers. The skill's setup mode can create the clone through the API with a helper from the HyperFrames media skills (heygen-voice.mjs clone <file> --name "Prajjwal"); ours is called "pj voice".

The speed problem. The first fix, on 9 October, was to slow the clone to HeyGen speed 0.9. It was not enough: measured on later scripts, whole lines at 0.9 came out at 2.8 to 3.0 words a second, and the first take of the rate-limiting long-form ran 318 seconds at 3.02 words a second. Our target is 2.0, and I cap revisions at 2.2. Slowing the whole line further made it drawl.

The fix was to stop voicing lines and start voicing sentences. voice_build.py sends each sentence on its own at speed 0.75, then joins a line's sentences with a 0.35-second breath. That lands under 2.2 words a second while keeping the gap between lines under 0.7 seconds. It has a second benefit: a fix to one sentence re-voices only that sentence, and takes are cached, so a rerun costs nothing.

The clipped-words problem. On 11 October I reported that "few words are getting cut… proper words are not hearable". The cause was ours. The earlier script trimmed each take at HeyGen's first-word timestamp, minus 80 milliseconds. Those timestamps run about 0.2 seconds late, so the trim sliced the start off a third of all sentences — "The" became "e", "Step" became "tep". On the Snackly promo, 12 of 44 sentences were clipped. Now each take is cut at its first and last audible 10-millisecond window (anything above 3% of the take's peak), with padding and 8 ms fades, and the build fails if a trimmed take still starts or ends on speech. Gate B17 makes deliver.py refuse any video whose voice files were not made by this script or were changed after it.

The rate limit. HeyGen's documentation lists 30 requests a minute for POST /v3/voices/speech on pay-as-you-go accounts, and a 429 Too Many Requests beyond that. We found it the hard way: on the rate-limiting long-form night it "refused 23 lines on the first try", and because the voicing ran as parallel batches, the refusals failed silently into a log. Now voice_build.py retries with backoff and jitter, up to six times, and never runs more than about four requests in parallel. (Yes, a video about rate limiting hit a rate limit.)

What it costs to make an AI video with HeyGen and HyperFrames

Every figure in this section is first-party unless it is marked as a list price.

Item	Figure	Source
HeyGen wallet loaded	$15	Our top-up
Wallet on 10 Oct, 13:08 UTC	$10.52	`GET /v3/users/me`
Wallet on 11 Oct	$6.80	`GET /v3/users/me`
HeyGen spent, all video work to date	$8.20	$15 − $6.80
Clone TTS, test 1	346 characters → 22.8 s of audio → $0.05	Balance before and after
Clone TTS, test 2	967 characters → 58.9 s of audio → $0.14	Balance before and after
Music retrieval	$0.00	Balance did not move
Agent run, temperature Short (85 s)	about $18.35 of a $25 cap; about $10 of it the 11 parallel frame workers	Run log, 9 Oct
Agent run, rate-limiting long-form + companion Short	about $26 of a $60 cap	Run log, 10 Oct
Daily video-idea job	about $0.25	Cron docs
Rendering	no per-render charge; our own 4-CPU machine	—

Three things follow from the table.

The voice is cheap, and nearly all the cost is the agent. The two tests put the clone at about $0.14 per minute of finished narration. Arithmetic, not a measurement: a clean single pass of the 415-second long-form is about 6.9 minutes of audio, roughly $0.97 of voice. The agent that wrote, reviewed and built that video ran for hours. The agent figures are Claude Code's own estimate of API spend, the same number --max-budget-usd checks; the documentation says it can differ from a bill.

Parallelism is the expensive part. On the temperature Short, the 11 frame sub-agents took about $10 of $18.35. Parallel workers are what make an 85-second Short with 11 distinct scenes possible overnight, but each one starts by loading the same skills and brief.

We cannot tell you what one video cost. The ledger has a cost_usd field, and it is null on all eight entries. The wallet total covers every voice take for twelve videos, the revisions, the abandoned takes and two pricing tests. If you build something like this, write the cost of each run into its ledger entry from day one.

Wallet or subscription? On 10 October, with about $10 left, we asked whether to keep topping up the wallet or take HeyGen's Creator plan. HeyGen's pricing page lists Creator at $29 a month, or $24 a month paid annually. Third-party write-ups say web-plan credits do not pay for API calls, which are billed separately; HeyGen's pricing page links to API pricing but does not spell that out, so treat it as unconfirmed. We are staying on the wallet. Our three tracks need on the order of 175 minutes of narration a month on clean first passes. That is our own estimate, and at $0.14 a minute it comes to about $25 before revisions.

What didn't work

Listed roughly in the order we found them. The visual ones cost render loops, and a loop on the Snackly revision took about 35 minutes.

Too fast. Two Sum, the first Short: 44 seconds, 97 words, nine beats. I liked the animation ("hats off to the animation") and said it was "too fast, too much content in just 44 seconds, we could have gone beyond a minute". The agent had optimised for research on short attention spans; the audience is people learning Python. Fix: teaching runs 60–90 seconds at no more than 2.0 words a second, with a hold after every reveal (A8). "Cut beats, never pauses."
The first unattended run stalled. On 9 October the run got as far as building frames and then could not run node or npx without a permission prompt nobody was awake to answer. Fix: allow Bash whole and deny the dangerous commands by name.
A HyperFrames helper deleted footage. The assembler moves each frame's video clip out of the frame file before checking the other frames; when a check fails it stops, and the clips are gone. Two clips vanished on the Page Arcade Short; the agent restored them and flagged it as a bug in the installed workflow, not in our code.
The videos looked alike. After the Page Arcade and ChitraYatra Shorts I wrote: "the last two videos were quite similar; this way it will soon be noticed as AI generated", and the real footage "was limited to very small space on screen". Fix: only the brand core stays fixed — the voice, one green accent (#00D890), a two-second end mark. The look changes every video, from a list of families that has grown to 15: blueprint, whiteboard, isometric 3D, documentary, split-screen, editorial paper and others. ledger.py look-check refuses a family used in the last three videos, or a hook type or caption style repeated from the previous one. Footage goes full screen (B11).
The script assumed an expert. The LLM-temperature Short was the first video where I said "the visuals & frames of this video was very good, I am impressed. But what's bad was the script itself." It skipped the foundation, explained the mechanism with maths, used idioms ("long shots") and spoke 17 numbers in 72 seconds. The review gate had flagged it twice and been overruled by the agent that wrote it. Fix: the fixed 12-year-old viewer, the linter, the teach-back with a separate judge, the expert review.
Hooks that meant nothing to a stranger. On the Snackly promo: "the whole video is good except the beginning… the hook doesnt make sense". Clever lines like "Ten comparisons, or five lookups" scored well on craft with a planner who already knew the topic. Fix: line one is the viewer's own question in their words ("Why does your shop's website load so slowly?"), and a before-and-after proves it by three seconds (A2, A20).
Soft footage we didn't notice. Chrome's screencast on our machine delivers 360×640 frames whatever size you ask for, so every screen recording before 10 October was a 3× upscale. Fix: capture with page.screenshot at device pixel ratio 3 instead, which gives true 1080-pixel frames at about 7.5 frames a second.
Frame 0 ignored the trim. The rendered MP4's first frame showed the clip's own first frame — prices and an "Add to cart" button — although every browser snapshot looked right. Fix: pre-trim clips with FFmpeg, and always decode frame 0 of the final file (B14 now does).
Silence between sentences. The first long-form had 3–5 second gaps from padded frames. Even a 2-second gap felt one second too long. Fix: B16 and gap_check.py, at most 0.7 seconds.
Clipped words, voice speed and the rate limit. All described above. The speed and the rate limit each cost 20 to 40 minutes on the night they were found.
Smaller traps. The machine cannot fetch Google Fonts, so the first-choice look for one video was abandoned; looks now use fonts already on disk. Background jobs die after ten minutes unless given a longer timeout. An earlier voice script reused stale audio. And when the server's timezone was switched from UTC to IST on 8 October, cron fired every job 5.5 hours early, the studio's slot had already passed, and no video was made that night; all 14 crontab entries were converted the next day. The HeyGen music search sometimes returns nothing, and two videos reused an earlier track.

What worked

Real footage beat everything we drew. The video I liked most was a blog explainer about Google's Gemini model taking on real jobs — "this is amazing. i loved this one." Its footage is the real source page: Google's announcement, captured with Puppeteer at 2×, with a green highlighter drawn on the exact sentences being discussed. The highlight coordinates were read from the page's DOM, not guessed. The claims in it follow Google's page rather than our own blog post. Where our post said a saving had "already" happened, Google's page said "once rolled out", and the video went with Google. That method is now the template for every blog video.

The simple style held up. Flat navy, one green accent and motion that shows a state changing — a pointer moving, a cell filling — got praise on the first day and still works. The isometric look on the temperature Short got the "very good, I am impressed".

Putting gates in code, not in prose. The rules that lived only in the skill's instructions were the ones bent under pressure: the third judge round and the final-file review above. No video has gone out without the lines and checks deliver.py enforces. The PASS lines, the voice manifest and the look-check are three short pieces of code that changed the output more than any amount of prompt wording.

Per-sentence voicing. It fixed the pace, made revisions cheap and, with the trim on real sound, fixed the clipped words. It is the single biggest improvement in how the videos sound.

You can watch what the method produces: Google gave its newest AI real jobs, the Jev explainer and how OpenAI trained agents to run enterprise software, all on our @cybiqonai channel. The audience for these is our LLMBytes daily AI blog.

How long a HyperFrames render takes

All renders ran locally on one machine: Ubuntu 24.04, 4 CPUs and 30 GiB of RAM, with HyperFrames using one worker. These are the timings from the render logs.

Video	Frames	Render time
AI agents long-form (7:04)	12,722	1,168 s (19.5 min)
Rate-limiting long-form	12,957	791 s
LLM temperature Short	3,600	526 s
Gemini blog explainer	3,518	427 s
Jev blog explainer	3,547	307 s
Snackly promo	2,224	188 s
Rate-limiting companion Short	2,669	144–185 s across four renders

Frame count is not the whole story: the rate-limiting long-form has more frames than the agents one and rendered in two-thirds of the time, because its scenes are simpler. The practical lesson is the one in the failure list. A render is cheap in money and expensive in time, so everything that can be checked before rendering — snapshots, the linter, the reviewers, the voice manifest — is checked before rendering.

How to set up HyperFrames and HeyGen on your own machine

The whole skill is now open source at cybiqon-ai/faceless-video-studio: clone it, run ./install.sh ~/my-studio, and follow its setup guide. The steps below are what that guide automates, if you would rather build your own.

1. Install the basics. HyperFrames needs Node.js 22 or newer and FFmpeg. We use Node 22 through nvm, Python 3.12 for the helper scripts, and FFmpeg 6.1 from apt.

sudo apt-get install -y ffmpeg
node --version   # 22 or newer

2. Install HyperFrames and its agent skills. In Claude Code, add the plugin; for other agents, install the skills directly:

claude plugin marketplace add heygen-com/hyperframes
claude plugin install hyperframes@hyperframes
# or, for any agent that reads skills:
npx skills add heygen-com/hyperframes

3. Make one video by hand first. Before automating anything, render one composition yourself, so you know what a good one looks like and how long your machine takes.

npx hyperframes init my-video
cd my-video
npx hyperframes preview
npx hyperframes check --strict
npx hyperframes render --quality high --output renders/video.mp4

4. Get a HeyGen API key and fund the wallet. API usage is billed per operation from a wallet. Keep the key out of your code:

echo 'HEYGEN_API_KEY=...' >> .env && chmod 600 .env
# check the key and your balance
curl -s -H "X-Api-Key: $HEYGEN_API_KEY" https://api.heygen.com/v3/users/me

The response includes wallet.remaining_balance. The older v2/user/remaining_quota endpoint still answers, but HeyGen marks it legacy and says it will be removed on 31 October 2026.

5. Clone your voice once. Record one expressive take of 90–120 seconds in a quiet room, as WAV, and submit the best 60–90 seconds. HeyGen's current instant-clone flow uploads the recording as an asset, creates the voice and polls it until it is active. Then voice a test paragraph and time it. If it is faster than about two words a second, don't just lower the speed — voice one sentence at a time.

6. Trim on sound, not on timestamps. Whatever TTS you use, find each take's first and last audible sound yourself and cut there, with a few milliseconds of padding and a short fade. Then listen to the first word of every sentence once.

7. Normalise loudness for social platforms. We use the same pass on every video:

ffmpeg -i renders/video.mp4 -c:v copy \
  -af loudnorm=I=-14:TP=-1.5:LRA=11 -ar 48000 -c:a aac -b:a 192k \
  -movflags +faststart video.mp4

8. Write your gates as code. Start with three: a script linter that fails long sentences and undefined terms, a delivery script that refuses a video without the review lines you require, and a voice check that refuses audio it didn't build. Add one every time you catch a failure by eye.

9. Only then, schedule it. Run your agent headless from cron with a lock, a timeout, a budget cap, a scoped tool list and no MCP servers, and judge success by counting a line your delivery script prints, never by the exit code. Expect the first unattended run to fail on something you never saw in an interactive session.

If you would rather have this built for your business than build it, that is the kind of AI agent and automation work we do.

Verdict

The studio works. Twelve finished videos in four days, narrated in my voice, with the research, the script, the design and the delivery done by an agent while I slept, for $8.20 of voice. I would not have believed that number on 7 October.

Three things I would carry to anyone building the same thing.

Your gates will come from your failures, not your foresight. Almost every one of the 37 checks was written the day a video failed that way. Plan for it. Make the first week about reviewing every video yourself and turning each complaint into a line of code that refuses the next bad video, rather than into another paragraph of instructions an agent can talk itself past.

Measure cost per video from the first run. The wallet tells us what all the voicing cost; the run logs tell us what two runs cost. Nothing tells us what a Short costs, which is the one number a business deciding whether to do this would ask for first.

The voice is the product. Animation is where the agent impressed us fastest, and the voice is where viewers will decide whether to stay. Pace, clipped words and silence between sentences took more fixes than every visual problem combined, and they were all invisible in a snapshot.

All figures are first-party unless marked. Video counts come from the studio ledger and the YouTube upload ledger; run costs from the agent's own reports in the run logs, which are Claude Code's estimates rather than a bill; the HeyGen wallet from its API on 10 and 11 October 2026; the TTS cost per minute from two before-and-after balance checks on 10 October; render times from HyperFrames' render logs; quality gates from the skill's rubric. Owner feedback is quoted from the notes made the day it was given. HeyGen's plan prices, rate limits and clone requirements were read from heygen.com and developers.heygen.com on 11 October 2026; the claim that plan credits don't cover the API is from third-party write-ups and is marked as unconfirmed.

FAQ

What is HyperFrames?

HyperFrames is an open-source framework from HeyGen, under the Apache 2.0 licence, that turns HTML, CSS, media and seekable animations into deterministic MP4 videos. A video is a web page whose elements declare their timing with data attributes. It renders locally with headless Chrome and FFmpeg, and needs Node.js 22 or newer. It ships agent skills so that coding agents such as Claude Code can write compositions.

Is HyperFrames free?

Yes. The framework and its CLI are open source under Apache 2.0, and rendering on your own machine has no per-render charge; you pay only in machine time. Our renders on a 4-CPU machine took between about 2.5 and 19.5 minutes per video. HeyGen also offers hosted rendering, which we have not used. HeyGen's voice, avatar and music APIs are paid separately.

How much does a HeyGen voice clone cost per minute of audio?

In our measurements on 10 October 2026, text-to-speech with an instant clone of our founder's voice cost about $0.14 per minute of finished audio, through HeyGen's pay-as-you-go API wallet: $0.05 for 22.8 seconds and $0.14 for 58.9 seconds. HeyGen's developer documentation lists professional-voice speech at 0.6 API credits per generated minute and does not publish a per-minute price for instant clones. HeyGen's documentation says creating an instant clone is free during its preview.

Can Claude Code make videos on its own?

Yes, with a renderer and a voice. Our setup runs Claude Code headless from cron with a custom skill that researches a topic, writes and lints a script, voices it with a HeyGen clone, builds frames with parallel sub-agents, renders with HyperFrames and sends the MP4 to Telegram. It made twelve finished videos in four days. It still needed a human to review every video and to post them.

Is the video studio open source?

Yes. The video-studio Claude Code skill is published at github.com/cybiqon-ai/faceless-video-studio under the MIT licence, with an installer, a starter studio, a filled-in example brand, and docs for setup, voice cloning, scheduling and every quality gate. You bring a HeyGen API key and your own voice; the agent runs in Claude Code and renders locally with HyperFrames. Our own studio runs the same public code, with only its config, brand and plugins kept private.

How long does a HyperFrames render take?

It depends on frame count and scene complexity. On a 4-CPU, 30 GiB Ubuntu machine with one render worker, a 74-second promo of 2,224 frames took 188 seconds and a 7-minute long-form of 12,722 frames took 1,168 seconds, about 19.5 minutes. Our other seven-minute video rendered in 791 seconds because its scenes were simpler.

What is the HeyGen API rate limit for text-to-speech?

HeyGen's usage-limits documentation lists 30 requests per minute for POST /v3/voices/speech on pay-as-you-go and subscription accounts, and 120 on Enterprise; going over returns 429 Too Many Requests. Parallel voicing hits that limit quickly. One of our runs had 23 lines refused, so voice sentences sequentially or with a small pool, and retry with backoff and jitter.

Do you need a HeyGen avatar to make AI videos?

No. We use no avatars at all. HeyGen supplies only the cloned voice and background music; every visual is an animated HTML scene, a real web page captured in a browser or real product footage, rendered by HyperFrames. Faceless explainers like these suit teaching content, and avoid the cost of avatar video.

How long should a YouTube Short be?

YouTube allows Shorts up to three minutes long. Our own teaching Shorts run 60 to 90 seconds at no more than two words a second, after our first 44-second Short was judged too fast to follow. Long-form explainers run four to eight minutes.

Sources

faceless-video-studio — the studio described here, open source (MIT), published 12 October 2026
HyperFrames on GitHub — HeyGen, Apache 2.0; README read 11 October 2026
HyperFrames quickstart — HyperFrames documentation
HeyGen API: Usage limits — HeyGen developer documentation
HeyGen API: Instant voice clone — HeyGen developer documentation
HeyGen API: HeyGen Voice — HeyGen developer documentation
HeyGen API: Get current user — HeyGen developer documentation
HeyGen pricing — read 11 October 2026
How to perfect your AI voice clone — HeyGen blog
Claude Code CLI reference — Anthropic
YouTube Shorts length — YouTube Help
awesome-opus5-5-videos — videos made with Claude and their prompts, MIT
FFmpeg loudnorm filter — FFmpeg documentation
EBU R 128: Loudness normalisation — European Broadcasting Union
We built our AI agents a wiki. They went straight to grep. — how the agents find their way around this codebase
We built the game in six days. The store review took fifteen. — the game whose footage appears in the studio's product Shorts

Originally published on cybiqon.in. Cybiqon is a small Indian software studio: websites, apps and AI automation for growing businesses. See what we build.

We deleted the voice bill. Now the studio posts its own videos.

Cybiqon — Sun, 18 Oct 2026 13:17:52 +0000

Six days ago I wrote up the first version of our video studio: a Claude Code agent that researched, scripted, voiced and rendered a video every night while I slept. It had made twelve videos in four days. It used a paid HeyGen clone of my voice, and every video still waited for me to post it by hand.

Since then the studio has made 28 more, 40 in ten days. It now clones my voice with open-source models that run on the same 4-core server that renders the frames, in English and in Hindi, so the voice line in our costs is $0. Three cron jobs run it every day: one for blog explainers, one for product Shorts and one for teaching videos. YouTube and X get their uploads from the scheduler at 18:30 IST, and the scheduler checks at 19:00 that they actually went public. Two new review gates make sure a topic is a problem real developers have, and that a second AI model from a different company has read the script before any voice is spent on it.

That is the headline. The fine print is that Instagram and Facebook are still posted by me, from my phone, with a caption the studio writes. The first X post made by cron goes out tonight. And the most useful thing we learned this week cost nothing to build: the owner (me) watched a Short, liked the visuals, and wrote "I learned nothing from it."

This post walks through the whole machine, stage by stage. It covers how a topic is chosen, how the script is reviewed, how the voice is cloned offline, how frames are built and rendered, and how a finished MP4 gets to YouTube and X. All of it is in faceless-video-studio, MIT-licensed, which you can install into Claude Code with one command. The last sections show how, and where to plug in your own uploader.

TL;DR

40 videos in ten days (8–17 October 2026), with no camera, no microphone session and no editor. By the studio's own ledger, that is 18 teaching videos (three of them 6–7-minute long-forms), 12 blog explainers, 5 product and service promos, and 5 made in the first two days, before the tracks were split. The total runtime is 65 minutes.
The voice now costs $0. HeyGen voice cloning was removed from the studio on 16 October. English is Pocket TTS by Kyutai, at about real time on 4 CPU cores. Hindi is IndicF5 by AI4Bharat, at about 30× real time. Both are cloned from my own recordings and run offline. The HeyGen voice had cost about $0.14 per minute of narration, and it stopped the pipeline the day its credit ran out.
The only required cost is Claude Code. The agent's runs cost $11–26 each by Claude Code's own estimate. The optional extras cost cents: $0.03 for the second-opinion script review and $0.015 per X post.
Three tracks a day, on cron. 12:30 blog explainer → YouTube, public, linked on the blog post. 15:15 product Short → YouTube scheduled for 18:30 plus X at 18:30, verified at 19:00. 23:00 teaching Short or long-form → Telegram for me to review.
40 pass/fail gates. The newest two, A21 and A22, check the topic and the script before any voice is made. A21 means a teaching video must start from a problem developers are visibly asking about online, with at least two links as proof. A22 means a model from a different company reviews every script and writes its own version. A new mix check keeps the music at least 20 dB under the voice.
Posting is the part that is still half-manual. YouTube and X are automatic. Instagram and Facebook are not yet. The studio delivers the MP4 and a ready caption to Telegram, and I post them.
You can run all of it. claude plugin marketplace add cybiqon-ai/faceless-video-studio installs the studio. A 30-second recording of your voice makes it speak as you. Four small Python plugins connect it to your own calendar, chat and storage, and a POST.json per video hands its titles and captions to your own uploader.

What changed since the first AI video pipeline

The first write-up was a snapshot from 11 October. This is the same studio six days later.

	11 October (post #1)	17 October (now)
Videos made	12 in 4 days	40 in 10 days
Voice	HeyGen instant clone, paid per minute	Pocket TTS (English) + IndicF5 (Hindi), offline on CPU, $0
Languages	English	English, Hindi (IndicF5 covers 11 Indian languages)
Quality gates	37, then 38	40, plus a loudness check that blocks delivery
Topic choice	rotation + "what's new this week"	a problem scout that proves real developers have the problem
Script review	three Claude reviewer agents	three Claude reviewer agents + a second model from another company
Viewer	"a smart 12-year-old"	a developer who already codes
Daily runs	1 (plus promo three days a week)	3: blog, product, teaching
Posting	all by hand	YouTube and X by cron; Instagram and Facebook by hand
Installation	clone + `install.sh`	one-command Claude Code plugin, or clone + `install.sh`

Four of those rows are changes of mind, not new features. The viewer, the topic rule, the voice and the posting all changed because something went wrong in front of real viewers. The sections below say what.

The daily schedule: three tracks, one server

Everything runs on one Ubuntu server with 4 CPU cores and no GPU, in IST.

Diagram: One studio day. The blog and product tracks run without me; the teaching track still ends with my review. See it in the original post.

Each track is the same skill run in a different mode by the same runner: bin/run.sh blog, bin/run.sh promo, bin/run.sh (daily). The tracks share one lock, so they never render at the same time on a 4-core machine. Each has its own time and spend ceiling: 2 hours and $20 for the blog, 75 minutes and $25 for the product Short, 3 hours and $25 for a teaching Short, 7 hours and $60 for a long-form night.

The teaching track follows a weekly rotation, set in config.json:

Day	Pillar	Format
Monday	AI term	Short, 35–60 s
Tuesday	Python	Short
Wednesday	AI deep dive	Long-form, 16:9, 4–8 min, plus a vertical companion
Thursday	Build a thing	Short
Friday	Tech news explained	Short
Saturday	AI term or Python	Short
Sunday	System design deep dive	Long-form, plus companion

A long-form for Wednesday renders on Tuesday night with a 7-hour ceiling. A render of a 7-minute video is about 12,700 frames.

Topic research: the problem scout (gate A21)

On 15 October I watched a Short the studio had made about stopping SQLite's VACUUM INTO on a read-only connection for an AI agent. It was true. The code had been run, and the footage was real. I wrote: "There's no point making a video on a problem which no one is facing."

The rotation had told the agent "AI term", and the agent had picked something that was new and interesting to it. Nobody had asked. A hook can't make a viewer recognise a problem they've never had. We shelved the video and added a step before anything else is chosen.

The problem scout is a fresh sub-agent with one job. It finds problems working developers are hitting this quarter in the day's subject, proves they have them, and ranks them. Its instructions:

At least 12 web searches across at least 4 kinds of source: Stack Overflow (the "frequent" and "votes" tabs), GitHub issues on popular tools, Hacker News "Ask HN" threads, Google's "People also ask", and official forums such as Python Discourse and the AI providers' developer forums. Reddit is on the list too.
Every problem is quoted in the asker's own words and proven with at least two links and their numbers: views, votes, 👍 reactions, comment counts, dates. "Don't invent numbers: if a count isn't visible, write n/a and score lower."
Each problem is scored 0–3 on five things: Frequency, Recency, Everyday, Showable in 35–60 s, and We can prove it. That makes a maximum of 15.
A problem needs 9 or more, and a 0 on Frequency or Everyday rules it out at any total. Interview questions are ruled out always. We don't make interview content.

The scout writes 8–15 ranked rows to research/problems.md, and every row goes into a persistent problem-bank.json. The next run reads the bank first: a high-scoring, unused problem from the last 30 days can be picked without searching again, as long as its evidence is re-checked.

Gate A21 enforces it in code. The plan must cite the chosen row, its words and its two links. Only then may the agent write A21: PASS (real problem). deliver.py refuses to deliver a teaching video without that line and without research/problems.md, however good the video is.

The rule changed the hooks too. A hook now opens on the viewer's situation, using the asker's words, before it names any tool. The best hook is often the question title itself, tidied up.

Two practical notes from running it:

Reddit blocks data-centre IPs. From our server, Reddit returns 403, and the free mirrors rate-limit agents. The scout copes because it needs four kinds of source, not Reddit in particular. If Reddit matters to your niche, use its official API with your own key.
A planned topic still gets scouted. When I put a topic in the content calendar, the scout doesn't overrule me. It finds the real problems people have with that topic, and if none scores 9, it says so in the delivery message.

After the scout, the agent does 5–10 more searches for the facts. ledger.py check refuses any topic close to a video the studio has ever made. Everything that will appear on screen is saved in the video's research/ folder first, including the output of the code it ran. "Nothing goes on screen that is not in this folder."

Script review: a linter, three reviewer agents and a second AI model

A script has to get through Gate A before a second of voice is made. Voice and frames are where the time goes, so this is the cheapest place to reject a video.

The viewer is fixed. In the first week the viewer was "a smart 12-year-old who never coded". The scripts that came out of it were clear, and I called them childish. Four Instagram Reels got 120–150 views each, and 67% of viewers swiped away in the first three seconds. Since 14 October the viewer is a developer or CS student who already codes. Known terms are never defined. Every Short carries at least one artifact worth saving — a command, a config, a number — and at least three named specifics every 30 seconds.

The hook is written three times. The agent drafts three hooks from a library of 20 templates taken from real tech Shorts, and scores each out of 12. Sentence one is at most 14 words and names the concrete subject plus a tension. The proof is on screen by 1.5 seconds, and something new happens every 10–15 seconds. A Short runs 35–60 seconds and ends on its payoff, with no recap.

Then the checks, in order:

script_lint.py (A18) checks the hook's length, banned openers ("In this video…"), sentences over 20 words, a jargon list, and the specifics-per-30-seconds count. It is 250 lines of plain Python, and it is the only reviewer that cannot be argued with.
A second opinion from another model (A22). second_opinion.py sends the script, with nothing else, to a model from a different company through OpenRouter. We use OpenAI's. It reviews the script and also writes its own version from the same facts. The Claude agent then decides point by point and records the outcome, e.g. A22: second opinion adopted 6, rejected 5. A model reviewing its own family's writing shares its blind spots. On its first run, the second opinion caught a Python datetime Short that said default=encode without ever showing what encode was. That had passed three Claude reviewers. It costs about $0.03 a script.
Three fresh Claude sub-agents, each seeing only the script and its brief:
- A16, new-to-me. A mid-level developer must name one concrete thing they learned and who they would send the video to. A separate judge grades that answer, because a reviewer that grades itself passes everything.
- A19, the expert. It flags anything that has become false by being simplified.
- A20, the cold viewer. It plays a developer scrolling Reels and sees only the first three seconds. Would they stop?

A hard fail gets one rewrite. A second fail sends the run back to pick a new topic, not to polish the old one.

None of this makes a script teach. On 15 October I watched a Short that had passed A16 and said I liked the visuals but learned nothing. A16 passing is a lower bound, not proof. The fix was the "artifact plus three specifics" rule above. The rules keep moving.

Cloning your voice offline, in English and Hindi

For the first week the studio used a HeyGen instant clone of my voice. It sounded good. It cost about $0.14 per minute of narration, allowed 30 requests a minute, and on 13 October its prepaid credit ran out mid-pipeline. I wanted the voice to be like the renderer: on our machine, with no meter.

We tested the open-source cloning models that run on a CPU and are licensed for commercial use:

Model	Result
XTTS-v2	Clones well and speaks Hindi, but its licence (CPML) forbids commercial use, and its Hindi sounded flat to native listeners. Rejected.
Chatterbox, NeuTTS	3–6× slower than Pocket TTS on our CPU, and they add an inaudible watermark. Rejected.
Pocket TTS (Kyutai)	English. A 100M-parameter model built for CPUs. Kyutai reports about 6× real time on a MacBook Air M4 using 2 cores; on our server it voices at about real time. Clones from a plain WAV of 20–30 seconds of you talking. Code MIT, model CC-BY-4.0. Chosen for English.
IndicF5 (AI4Bharat)	Hindi and 10 other Indian languages. About 30× real time on 4 cores, so a 60-second Short takes about 30 minutes, overnight. Needs a 6–10 second reference clip and its exact words. MIT. Chosen for Hindi.

Both models are gated on Hugging Face: you accept their terms once with a free account. Both sets of terms say the same thing: clone only voices you have explicit permission to clone. Here, that's my own. install_voice.sh pocket or install_voice.sh indicf5 puts each one in its own virtualenv with a CPU build of PyTorch, because their dependencies conflict. tts_engine.py is the one interface the rest of the studio sees: an engine class with say(text) → samples. Adding a third engine is a class and an install recipe.

How a voice track is built (voice_build.py, 292 lines):

The script is split into sentences, including on the Devanagari full stop । for Hindi.
The engine loads once and voices each sentence as its own take. Takes are cached by a hash of the text, engine, reference and speed. So when I ask for one line to change, only that line is re-voiced.
Spoken spellings come from hf/say.json. The engine says "timeout equals three point oh five, ten" while the caption keeps timeout=(3.05, 10).
The speed is set after synthesis with FFmpeg's atempo, which keeps the pitch. My English clone at 1.0 was too fast for anyone learning. 0.64 sounded drawn out, and 0.82 stuck. IndicF5 speaks Hindi at a comfortable pace already, so it stays at 1.0.
faster-whisper transcribes each take for word timings, which drive the captions. With best_of: 3, each sentence is voiced three times and the take Whisper hears closest to the script wins.
Each take is trimmed on the real sound, never on timestamps. The cut is at the first and last 10 ms window louder than 3% of the take's peak, with a little padding and 8 ms fades. Our first trim used word timestamps, which run about 0.2 seconds late, and it cut the start off a third of all sentences: "The" became "e". On one promo, 12 of 44 sentences were damaged.
The takes are joined with a configurable breath between sentences. I wanted about a second of silence after every sentence, so our studio uses 0.82 s.
voice_build.json records a hash of every voice file. Gate B17 refuses a video whose voice wasn't made by this script, or was changed after it, or has a take that starts or ends on speech.

Recording the reference matters more than the model. Some of what we learned:

The clone copies the room. Pick a quiet room over a good microphone. A phone voice note 15 cm from your mouth is enough.
Read expressively. A flat reading gives a flat clone.
Record in the language the clone will speak. A Hindi voice cloned from English sounds like an English speaker reading Hindi.
Background hiss is cloned too. FFmpeg's RNNoise filter (arnndn) removes it.
For IndicF5, keep the reference short. F5 cuts a reference longer than about 15 seconds but keeps all of its transcript, so it thinks you speak faster than you do and chops the ends off words. Our first Hindi takes had exactly this bug. A 6.7-second clip fixed it, and the same lines came out 21.7 seconds long instead of 15.7. tts_engine.py now refuses a reference over 12 seconds.
Write Hindi the way people talk. Hinglish — "तो हुआ ये कि…", "अब सोचो…" — sounds alive. Textbook Hindi, voiced correctly, still sounded flat.

A second voice is a variant in config.json, chosen per video with voice_build.py --voice hi:

"voice": {
  "engine": "pocket",
  "reference": "voice/sample.wav",
  "language": "english_2026-04",
  "speed": 0.82,
  "lufs": -16,
  "variants": {
    "hi": {
      "engine": "indicf5",
      "reference": "voice/hindi.wav",
      "reference_text": "यार, आज एक मज़ेदार चीज़ हुई। …",
      "asr_language": "hi",
      "speed": 1.0
    }
  }
}

The Hindi voice is wired in and tested, but no Hindi video has been published yet. That is next on the list, not something we've proven with viewers.

Loudness: voice at −16 LUFS, music 20 dB under, and a mix gate

On 16 October I wrote: "the voiceover is still low." Pocket's takes came out 2–3 dB quieter than HeyGen's had been, and one music bed at a volume of 0.16 was only 13 dB under the voice. Both were fixed with a rule — never raise the music to compensate, only bring the voice up — and with code:

Every voice line is levelled to −16 LUFS with a gentle compressor, a static gain and a −1.5 dBFS limiter. We don't run FFmpeg's loudnorm on each line, because it pumps on a 5-second clip.
mix_check.py computes each music bed's effective loudness: its file LUFS plus 20·log10 of its volume in the composition. The mean voice must be at least 20 dB louder than the loudest bed. --fix rewrites the bed volume, and deliver.py refuses a video that fails.
The final file goes through one loudnorm pass to −14 LUFS integrated, −1.5 dB true peak. Spotify documents −14 LUFS as its normalisation target, and YouTube's is widely reported to be the same, so the platforms shouldn't turn us down or up much. (Broadcast, under EBU R 128, is −23.) The video stream is copied untouched, and the audio is AAC at 192 kb/s, 48 kHz.

Frames: 22 looks, a signature beat, and real footage

Viewers judge the voice first and the look second. In the first week I told the agent two videos looked so alike that "it will soon be noticed as AI generated". Since then the look is a choice the agent has to justify, and a gate it has to pass.

22 look families. Blueprint, whiteboard, documentary, split-screen, isometric, editorial paper, collage-scrapbook, and seven hand-drawn styles: pixel-era, riso-poster, ink-machine, math-board, iso-hairline, cut-paper and sketchbook. The 40 videos so far have used 22 different looks between them. ledger.py look-check refuses a family used in the last six videos. Only the brand core stays fixed: the voice, one green accent and a two-second end mark.

One signature beat per video. Every video has one hero moment that the last five videos didn't have. It might be a registry block from HyperFrames, a Three.js or Lottie scene, a hand-drawn animate moment or a Manim transform. It is recorded in the ledger so it can't repeat.

Three engines. HyperFrames is the main one: every frame is HTML, CSS and a paused GSAP timeline, rendered deterministically by headless Chrome and FFmpeg. The seven hand-drawn styles come from animate by cth9191, vendored at v0.4.0, and may cover at most about 70% of a video. Manim is optional, for maths and diagrams, rendered to transparent WebM and laid over a HyperFrames scene.

One sub-agent per frame, in parallel. The plan breaks the script into beats. Each beat gets a fresh Claude sub-agent that builds that frame's HTML from the plan, the look's design file and the voice timings. The 85-second Short in the first post had 11; a long-form has 25–45 and is built in waves of 8. A script assembles them into one composition. This is where most of the agent's spend goes: on the first version's 85-second Short, about $10 of $18.35 was the 11 frame workers.

Real footage beats anything drawn. The videos I've liked most show the real thing:

Blog explainers capture the source page itself at 2× in a headless browser and draw a highlighter on the exact sentences being discussed. The rectangles are read from the page's DOM, not guessed.
App and game Shorts use the real app. For our Flutter games, a flutter_test harness drives the real level screen with the solver's own moves and saves 1080×1920 frames. Lumina's Short showed a mechanic, then a solver-proven number, and I loved it. The rule in the skill: "Never mock gameplay or UI."
Web footage is captured with page.screenshot at device pixel ratio 3 in a loop. Chrome's screencast API on our server delivers 360×640 whatever size you ask for, so every screen recording before 10 October was a 3× upscale.

Rendering video with HyperFrames on a CPU

npx hyperframes render --quality high turns the composition into an MP4 on the same 4-core server, in headless Chrome. Shorts are 1080×1920 and long-forms 1920×1080, both at 30 fps. Renders have taken from 2.5 minutes for a short promo to 19.5 minutes for a 7-minute long-form of 12,722 frames. There is no GPU and no cloud render.

Before rendering, mix_check.py --fix sets the music. After rendering, the final loudness pass runs. Then Gate B looks at what was actually made:

hyperframes check --strict passes (B1).
Safe zones, font sizes, one accent per frame, and no "AI slop" tells such as gradient text, neon, Inter/Roboto/Poppins, stock people or emoji (B2–B5).
Footage fills at least 80% of the frame for at least half the runtime (B11). A fresh agent compares this video's contact sheet with the last three and fails it if they look like one template (B13).
A judge reviews at least six frames decoded from the final MP4, including frame 0 (B14). Browser snapshots once looked perfect while the rendered first frame showed a clip's untrimmed opening, with prices and an "Add to cart" button.
gap_check.py caps the silence between lines (B16). fill_check.py fails a Short whose bottom 40% is empty in more than a quarter of sampled frames (B18).

A frame that fails goes back to its sub-agent. After two loops the run delivers with the failure noted, rather than burning the night.

40 quality gates, and the failures behind them

Twenty-two gates check the plan (A1–A22) and eighteen check the build (B1–B18). Eight are enforced in code — A16, A18, A19, A20, A21, A22, B17 and B18 — and deliver.py will not deliver a video without them. The rest are rubric rules that agents check and record. Version 1.1.0 of the repo, released with this post, documents all 40.

Almost none were in the first version. Each was added on the day a video failed that way:

What went wrong	Gate it produced
The first Short: 97 words in 44 s, "too fast, too much content"	A8: 35–60 s, pauses kept
A script that "considers the viewer as an expert", then a rewrite called "childish"	A14–A16, A18: fixed developer viewer, linter, new-to-me review with a separate judge
Three simplifications that had become untrue	A19: expert review
"The hook doesn't make sense"; 67% swiping away in 3 s	A2, A20: subject + tension in ≤ 14 words, cold-viewer test
A true, well-made video about a problem nobody has	A21: problem scout, ≥ 2 links, ≥ 9/15
A script that named a function it never showed	A22: second opinion from another model
Two videos so alike "it will soon be noticed as AI generated"	B11, B13, the look rotation
A rendered first frame that differed from every snapshot	B14 on the final file
3–5 s silences from padded frames	B16
A third of sentences losing their first syllable	B17
The bottom 40% of every Short left empty	B18
"The voiceover is still low"	Voice levelling + `mix_check.py`

The lesson hasn't changed since the first post, but we've seen it more often: rules written in prose get bent under pressure; rules checked in code don't. Every gate that deliver.py checks has held. The ones only described in the skill's instructions are the ones an agent eventually talks itself past at 2 a.m.

Posting to YouTube and X automatically, and why Instagram isn't yet

The open-source studio stops at the MP4. It delivers the video and a post kit and never posts by itself. That is on purpose: you should decide what goes out under your name, and how. Our own posting layer is about 700 lines of standard-library Python in our private ops repo. It reads exactly what the studio leaves behind, so here is how it works.

What the studio hands over. Every delivered video has a POST.json that deliver.py validates against a schema: three title options, a YouTube description, a caption with no URLs, hashtags, a pinned comment, a thumbnail_at timestamp, sources, notes, the cost, and the look used. Tracked links are built in code with utm_source, utm_medium=video and utm_campaign=<date>-<slug>. deliver.py sends the MP4 and a readable version of the kit through the notify plugin (Telegram by default) and prints one line a scheduler can grep:

Rendered: orbitone-one-tap 51s 20.4MB msg 1769 parts=1

YouTube goes through the YouTube Data API v3 with a resumable upload:

The blog explainer uploads public into its playlist. The description is POST.json's plus a "Read the full post" link. The upload's video ID is then written onto the blog post, so the post and the app show the video. If the site hasn't rebuilt since the post went up, the script asks GitHub to redeploy it.
The product Short uploads private with status.publishAt set to 18:30 IST, into a playlist per product. The playlist is created the first time a product appears. If the render finished after 18:30, it goes public at once.
A 19:00 job reads the video back, checks it is really public, marks it posted on our content calendar, and sends me an alert if not.
An upload ledger keyed by slug makes every call idempotent. The 14:00 retry re-runs the whole blog job, and a video that already went up is never uploaded twice.

Two notes for anyone building the same thing. First, our scripts were written for a rule from 2020: uploads from an API project that hadn't passed Google's audit were locked to private. Google's current reference now says videos from unverified projects "are not restricted to private viewing mode", and our public uploads since 16 October have stayed public. Either way, the script reads back the privacy YouTube actually applied rather than trusting the one it asked for. Second, quota isn't a problem at this scale. Since June 2026 uploads have their own bucket of 100 videos.insert calls a day, and we use three.

X gets the same MP4 at 18:30 through the X API v2 chunked media upload, then a post. The script signs requests with OAuth 1.0a using only Python's standard library: hmac, hashlib and urllib, with no Twitter SDK. X's pay-per-use pricing made one design decision for us. A post costs $0.015, but $0.20 if its text contains a URL, and X turns a bare cybiqon.in into a link too. So the post text is the caption's first and last paragraphs plus two hashtags, at most 280 characters, and the script refuses to post if any link survives. The link lives in the bio. One post a day is about $0.45 a month. Tonight, 17 October, is the first post made by cron.

Telegram gets every video, from all three tracks, with the post kit. That is where I review the teaching videos. The bot is two-way: it is a Claude Code session in tmux with the Telegram plugin, so "make the hook shorter and re-render" from my phone becomes a revise run.

Google Drive gets every final render through an archive plugin, because the server deletes heavy media after delivery.

Instagram and Facebook are still posted by hand. Instagram does have a content-publishing API, and Reels are supported. To use it we'd need an Instagram professional account, a Meta app with the content-publishing permission at advanced access, and every video hosted at a public URL for Meta to fetch when we publish. Through Facebook Login the account must also be connected to a Facebook Page. The limit, 100 API-published posts in 24 hours, is no obstacle. None of that is hard, but it hasn't been done. Until it is, the studio writes the Instagram caption and I post from my phone. That takes about a minute, and it is honestly where the pipeline leaks. Of 40 videos made, only the YouTube and X uploads are posted without me.

Running Claude Code unattended, safely enough

Cron calls bin/run.sh, which is 140 lines of bash. The important line:

flock -w "$WAIT" -E 75 "$LOCK" timeout "$LIMIT" claude -p "/video-studio $MODE" \
  --permission-mode acceptEdits \
  --allowedTools "Read,Write,Edit,Glob,Grep,WebSearch,WebFetch,Skill,Task,TodoWrite,Bash" \
  --disallowedTools "Bash(git push:*),Bash(rm -rf:*),Bash(curl:*),Bash(wget:*),Bash(sudo:*),Bash(crontab:*),Bash(ssh:*),Bash(scp:*)" \
  --strict-mcp-config --mcp-config '{"mcpServers":{}}' \
  --max-budget-usd "$BUDGET"

What each part is for:

flock stops two tracks from rendering at once. A second run waits up to two hours for the lock.
timeout and --max-budget-usd cap time and spend per run. A long-form night gets 7 hours and $60. The runner reads the day's format from the ledger before it starts. The budget is Claude Code's own estimate and a run can go a little past it, so set it below what you can afford.
Allow Bash, deny the dangerous commands by name. The first unattended run stalled at a permission prompt for node that nobody was awake to answer. A headless run can't answer prompts, so a per-command allowlist only stalls it. The deny list is the safety: no pushing, no downloads with curl or wget, no sudo, ssh or crontab, no rm -rf. There is no --dangerously-skip-permissions.
No MCP servers load in a studio run. The agent gets exactly the tools above.
Success is a count, not a status. The run must print deliver.py's Rendered: line. If it doesn't, the runner sends an alert saying why: killed by the time limit, lock held, Claude logged out, credits or usage limit reached, or "exited 0 but nothing was delivered". We learned this one the hard way on other jobs. An exit code of 0 had meant "did nothing" for 33 nights in a row.

What an AI video studio costs to run

Item	Cost
Voice (Pocket TTS, IndicF5)	$0, CPU time: ~1× real time English, ~30× Hindi
Rendering (HyperFrames)	$0, CPU time: 2.5–19.5 min a video on 4 cores
Captions (faster-whisper)	$0
Server	the 4-core Linux machine you already have
Claude Code, per run	$11–26 by Claude Code's own estimate. Short runs logged $11.0–20.5; the first long-form plus companion was about $26
Optional: second-opinion review (A22, OpenRouter)	about $0.03 a script
Optional: X posting	$0.015 a post with no link, $0.20 with one
Optional: HyperFrames music and sound-effect search	uses a HeyGen API key if you set one; the voice never does

Claude Code is the only cost the studio needs. The figures above are what Claude Code reports at API prices. On a Claude subscription, the runs use your plan's usage instead of adding a bill.

We still don't know the full cost per video. Only 6 of the 40 ledger entries have cost_usd filled in. In the first post I said that was the first thing I'd do differently. It's still the first thing. Fill it in from day one.

What didn't work

The "smart 12-year-old" viewer. It fixed scripts that assumed an expert, then overcorrected into scripts I called childish, and 67% of Instagram viewers left in three seconds. Fix: the viewer is a developer who codes, with an artifact and three specifics every 30 seconds.
Interesting topics nobody needed. A correct video about a SQLite edge case that no one asks about. Fix: the problem scout and A21.
Gates that pass a script that doesn't teach. A16 passed a Short I learned nothing from. Fix, partial: a model from another company reviews and rewrites every script (A22). The honest version is that review agents raise the floor, and a viewer still has to tell you if it teaches.
A voice on a meter. HeyGen credit ran out on 13 October, in the middle of a run. Fix: open-source voices on our own CPU.
A long Hindi reference chopped every word. F5 cut the reference at 15 seconds but kept its whole transcript. Fix: a 6–10 second clip, and code that refuses anything over 12.
Quoted phrases disappeared. Pocket dropped "tool query" from sees "Error executing tool query" in 5 of 5 takes. Fix: no quotes in spoken text.
The voice got quieter when we switched engines. Fix: levelling to −16 LUFS and a mix gate, never louder music.
Reddit blocks the server. Fix: the scout needs four kinds of source, not one site.
Tracking. Most ledger entries have no cost and only two are marked posted. Posting by hand meant the "posted" count was always behind. Fix, partial: automated posts mark themselves.

What worked

Real footage, again. The blog explainers built from the source page, and the game Shorts built from the real game, are still the videos I like best. The studio's rule now is to show the real thing whenever one exists.

Moving the voice onto our own machine. It removed a bill, a rate limit and an outage in one change. Revisions became free: re-voicing one sentence costs a few seconds of CPU.

A second opinion from a different model. For three cents it caught a gap that three reviewers from the same family missed. Not all its advice is good — on one script the agent adopted 6 points and rejected 5 — but having the decision recorded is the useful part.

Letting a calendar choose some topics. The planner plugin lets me put a topic on our content calendar and have the studio make it, mark it made, and still prove a real problem behind it.

Posting product Shorts with no human step. Since 16 October a product Short is made at 15:15, scheduled, published at 18:30 and verified at 19:00 every day, without my input. It's the first track where "made" and "posted" are the same number.

Install it in one command and plug it into your pipeline

You need Linux (macOS works with GNU timeout and flock from Homebrew), Node.js 22+, Python 3.10+, FFmpeg, Claude Code, a free Hugging Face account and about 5 GB of disk. No GPU.

1. Install HyperFrames and the studio as Claude Code plugins:

claude plugin marketplace add heygen-com/hyperframes
claude plugin install hyperframes@hyperframes

claude plugin marketplace add cybiqon-ai/faceless-video-studio
claude plugin install faceless-video-studio@faceless-video-studio

As a plugin, the command is /faceless-video-studio:video-studio, and it updates itself. If you'd rather own the files, clone the repo and run ./install.sh ~/my-studio. That checks your tools, links the skill into ~/.claude/skills/video-studio and creates a studio folder.

2. Install a voice and record yourself. Accept the model terms on Hugging Face, then:

pip install -U huggingface_hub && hf auth login
STUDIO_ROOT=~/my-studio skill/video-studio/scripts/install_voice.sh pocket    # English
STUDIO_ROOT=~/my-studio skill/video-studio/scripts/install_voice.sh indicf5   # Hindi, optional

Record 20–30 seconds of yourself speaking naturally to ~/my-studio/voice/sample.wav. The repo's voice guide has an English and a Hindi script to read.

3. Set up and make a video:

cd ~/my-studio && claude
> /video-studio setup                          # checks tools, voices two test lines for you to approve
> /video-studio plan "why my requests call hangs forever"   # research + plan + Gate A, no voice spend
> /video-studio daily                          # the full run: today's pillar from your rotation

Edit brand/brand-core.md (your accent colour and handle), brand/pillars.md (your audience and products) and brand/products.json (where promos link) to make it yours. The repo's examples/cybiqon/ is our real, filled-in brand.

4. Put it on a schedule once a few manual runs look right:

0 23 * * *  STUDIO_ROOT=/home/you/my-studio /home/you/faceless-video-studio/bin/run.sh
30 12 * * * STUDIO_ROOT=/home/you/my-studio STUDIO_LIMIT=2h STUDIO_BUDGET=20 /home/you/faceless-video-studio/bin/run.sh blog

Cron has a short PATH, so set it to wherever claude, node and npx live.

5. Plug it into your own systems. Four optional plugins, each a small Python file named in config.json, connect the studio to private systems without forking it:

Plugin	What it does	Our use
`planner`	`topic(day, track, pillar, slot)` lets a content calendar choose topics; `mark_made()` marks them done	our content calendar
`notify`	`send()` and `send_video()` deliver the MP4 and post kit	Telegram (built in); Slack, email or your own bot work the same way
`links`	builds tracked links for each product	UTM links to our apps and sites
`archive`	`store(video, post, revision)` keeps the final render elsewhere	Google Drive

For automatic posting, run your own uploader after the run, the way ours does. Wait for the Rendered: line, read the video's POST.json for the title, description and caption, and upload hf/renders/video.mp4. Make it idempotent with a ledger keyed by slug, print a count line, and verify the result separately.

If you'd rather have this set up for your business than build it yourself, this is the kind of thing we build for clients.

Verdict

Ten days in, the studio makes three videos a day on a machine with no GPU. The only bill it needs is Claude Code. The voice is mine, made offline, in two languages. Half of the output reaches viewers without me touching it.

Three things I'd tell anyone building the same thing:

Own the slow, metered parts. The voice was the one stage that could fail for reasons outside our machine, and it did. Moving it to open-source models removed the cost, the rate limit and the outage. It also made revisions free, which changes how picky you can afford to be.

Make the agent prove the topic, not just the facts. We had built gates for true facts, clear hooks and good frames, and still made a correct video nobody needed. The cheapest gate in the studio is the one that runs first: show me two people asking about this.

Automate the last step, or count it honestly. For a week the studio made videos faster than I posted them, and the ledger's "posted" column said so. Whatever you automate, measure the number that reaches viewers, not the number rendered.

All figures are first-party unless marked, as of 17 October 2026. Video counts, durations, look families and per-run costs come from the studio's ledger (cost_usd, filled for 6 of 40 entries) and run logs. Run costs are Claude Code's own estimates, not a bill. YouTube uploads come from the upload ledger; X prices from our X API account and X's pricing page; the second-opinion cost from OpenRouter usage. Voice speeds, reference limits and the rejected models come from the studio's voice tests between 13 and 16 October. Render times come from HyperFrames' render logs. Gates come from the skill's rubric. Owner feedback is quoted from notes made the day it was given. Instagram view figures are from four Reels, as reported on 14 October.

FAQ

Is the Faceless Video Studio free?

Yes. The studio is open source under the MIT licence at github.com/cybiqon-ai/faceless-video-studio. Its voice (Pocket TTS and IndicF5), captions (faster-whisper) and renderer (HyperFrames) are free and run on your own CPU. The only required cost is Claude Code, which runs the agent. Our runs cost $11–26 each at API prices, or come out of a Claude subscription's usage.

Can I clone my voice for free, offline?

Yes. Pocket TTS by Kyutai clones an English voice from 20–30 seconds of recording and runs at about real time on 4 CPU cores. IndicF5 by AI4Bharat clones Hindi and 10 other Indian languages from a 6–10 second clip and its transcript, at about 30 times real time. Both are free to download from Hugging Face after accepting their terms, and nothing is uploaded.

Do I need a GPU to make AI videos with Claude Code?

No. Our studio runs on a 4-core Linux server with no GPU. Voice cloning, captioning and HyperFrames rendering all run on the CPU. A Short renders in a few minutes, and a 7-minute long-form took 19.5 minutes. The Hindi voice is the slowest step, at about 30 minutes for a 60-second Short, which a nightly schedule hides.

Does the studio post to YouTube, Instagram and X automatically?

The open-source studio delivers an MP4 and a post kit, and does not post by itself. Our own uploader posts the product Shorts to YouTube and X and the blog explainers to YouTube automatically, using the YouTube Data API and the X API. Instagram and Facebook are still posted by hand: Meta's publishing API needs an Instagram professional account, a Meta app with the publishing permission, and each video at a public URL, and we haven't set that up yet.

Does it still need HeyGen?

No. HeyGen voice cloning was removed on 16 October 2026 and replaced with Pocket TTS and IndicF5. HyperFrames, the renderer, is an open-source project from HeyGen under Apache 2.0, and needs no HeyGen account. An optional HeyGen API key only enables HyperFrames' own music and sound-effect search.

Which languages can the studio speak?

English through Pocket TTS, which also supports French, German, Spanish, Italian, Portuguese and Dutch. Through IndicF5 it speaks Hindi, Bengali, Gujarati, Marathi, Punjabi, Odia, Assamese, Tamil, Telugu, Kannada and Malayalam. Each language is a voice variant in the studio's config, chosen per video.

How does the studio choose video topics?

For teaching videos, a problem-scout agent searches Stack Overflow, GitHub issues, Hacker News, Google's "People also ask" and developer forums for problems working developers are asking about. Each problem needs at least two links with their numbers and a score of 9 or more out of 15. The studio refuses to deliver a teaching video without that proof.

How long does one video take to make?

A product Short takes about 75 minutes from start to delivery, most of it research, review agents and parallel frame building. The render itself takes 2.5–19.5 minutes. The runner caps a Short at 3 hours and a long-form at 7.

Sources

faceless-video-studio — the studio described here, MIT
faceless-video-studio: cloning your voice — the voice method and measurements
faceless-video-studio: all gates — every gate and the failure behind it
HyperFrames on GitHub — HeyGen, Apache 2.0
Pocket TTS on GitHub — Kyutai
Pocket TTS on Hugging Face — model card and licence
IndicF5 on GitHub — AI4Bharat
IndicF5 on Hugging Face — model card
faster-whisper — SYSTRAN, MIT
animate — cth9191, MIT
Manim Community — MIT
HyperFrames documentation — HeyGen
YouTube Data API: Videos: insert — Google; upload quota and the status.privacyStatus note
YouTube Data API: Videos resource — status.publishAt can be set only on private videos
YouTube Data API: revision history — the 2020 private-lock rule and the 2026 quota buckets
X API pricing — $0.015 per post, $0.200 per post with a URL
X API: chunked media upload — X developer documentation
Instagram Platform: content publishing — Meta for Developers
Claude Code: run programmatically — Anthropic, claude -p
Claude Code CLI reference — Anthropic
Claude Code plugin commands — Anthropic
FFmpeg loudnorm filter — FFmpeg documentation
Spotify: loudness normalisation — the −14 LUFS target
EBU R 128: Loudness normalisation — European Broadcasting Union
Twelve videos in four days. Nobody picked up a camera. — the first version of this studio
We built the game in six days. The store review took fifteen. — one of the games whose real footage appears in the product Shorts
Eight bots played all 500 levels — the solver behind the "solver-proven" numbers in the game Shorts

Originally published on cybiqon.in. Cybiqon is a small Indian software studio: websites, apps and AI automation for growing businesses. See what we build.