reelline · open source · November 2026
Cheap, good and fully automatic: an open-source engine for short-form video
An automated short-video channel has three requirements, and they pull against each other. It has to be cheap, or it can't post every day. It has to be good: a script that's right and worth hearing, and animation with enough variety that day 40 doesn't look like day 1. And it has to be automatic, or it's just a faster way to do the work yourself. Cheap and automatic usually means slop. Good and automatic usually means expensive. Good and cheap usually means you're doing it by hand.
This engine does all three at once, and it's now open source: github.com/francuza9/reelline. Give it a list of websites, and every evening it hands you a finished reel. It finds a story worth telling, fixes the facts, writes the script, checks it against the source, voices it, animates a host and schedules the reel on YouTube Shorts, TikTok, Instagram and Facebook. It costs about 40 cents a reel in API calls, plus the server it runs on. Once a week it grades its own reels and feeds the grades back into the writing. The operator's part is one tap in Telegram.
See it run first: the 45-second demo shows the whole chain, and the channel it runs is on YouTube, TikTok and Instagram.
Yvito: the experiment I run on it
I built the engine for Yvito TV, a Georgian short-video channel with a cartoon host, and Yvito is still where I try things. I've run it with different moods for the host, different animation intensities, jokes and no jokes, cold opens on and off, a few fact cards on screen or one for every number. Each of those is a setting, not a rewrite. What the audience liked is a different story. What matters here is that the same engine ran all of it.
The numbers in this essay come from that channel: 63 scripts and 58 published reels between late September and mid-November 2026, in Georgian, a language most models have seen very little of. If the engine holds up there, it holds up in English.
The chain
- SourcesRSS, JSON, web pages
- Assess · AIlabels + 0–10 score
- Pick · coderules, then score
- Brief · AIfacts, or not stated
- Writer agentplain facts only
- Style agentadds 2–3 jokes
- Proofreadgrammar only
- Fact-checkclaims vs the source
fails: back to the step that broke it
- Voice + animationlip-sync, Remotion
- QAfile, sound, frames
- One human tap24 h before the slot
- Four platformsYT, TikTok, IG, FB
- Stats + Sunday rankingbest and worst openings
every Sunday back to the writer
Every evening at 17:30 the chain runs for tomorrow's reel. Each step is a small program with one job, and each one distrusts the step before it. A failing fact-check sends the script back to whichever pass broke it, and the weekly ranking feeds the story pass the openings that worked.
Cost: about 40 cents a reel
Every paid call is written to a ledger, and the bot sends a monthly report. On Yvito, in October and the first half of November, all model and API spend came to $0.42 and $0.40 per published reel. That is everything: the models for the writing and checking, text-to-speech, the vision model that picks and checks pictures, failed runs, and the assessment of every story that was never picked. At one reel a day that's about $12 a month.
Three choices keep it there:
- The expensive model only writes. The strongest model writes: the story, the jokes and the proofread. Assessing stories, building briefs and fact-checking go to a cheaper model from another provider. Writing is the biggest line on the bill, about 60% in November; checking every claim costs about 2%.
- Nothing paid runs twice. Each pass is stored the moment it finishes, so a retry resumes from the step that failed. Voice clips and images are cached, so a re-render costs nothing in API calls.
- The only other cost is the server. Remotion renders the 44-second reel on the same small server that runs everything else, in about eight and a half minutes, inside a capped slice next to two other products. There is no per-reel fee for rendering.
Quality: a script you can trust
The script is the most sensitive part. A model that writes freely also invents freely, and these reels are about real deadlines. One rule keeps it honest: the model that adds personality never writes facts, and code checks that it didn't.
- The facts are fixed before anyone writes. A cheaper model turns the source page into a brief with fixed fields: what it is, who can apply, the deadline, the cost, how to apply. A field the page doesn't state is written as "not stated", and the writer is told to leave that beat out, never to fill it in. Any number whose digits don't appear in the source is flagged. Earlier still, a deadline only counts if the model can quote the exact words in the story that state it.
- Two writers, two jobs. The writer agent writes the reel in plain Georgian: what the opportunity is, who can apply, by when, for how much, and how. No jokes. A style agent gets that draft as locked text and adds the style: in Yvito's jokey mode, two or three jokes; in its straight mode, no jokes, only the on-screen cards and the formatting.
- Code checks the lock. After punch-up, a plain Python function lines the draft's sentences up against the final script, fuzzily and in order. Each draft sentence comes out unchanged, edited or dropped. Each final sentence that matches none is marked as inserted. By construction, the inserted sentences are the jokes.
- The fact-check knows which sentences are jokes. The checker lists every factual claim in the script with a verdict (supported, unsupported, distorted) and the quote from the source behind it. Jokes about the viewer, about groups of people or about the host himself aren't claims. A joke about the news is: a punchline that names a deadline is checked like any other claim. The inserted sentences arrive marked, and the checker is told they are the likeliest place for a wrong fact.
- Repair goes to whoever broke it. If only joke sentences fail, punch-up runs again on the same draft, with the failures listed. If a draft sentence fails, the story pass runs again, then punch-up. A second failure doesn't publish and doesn't vanish: the reel reaches review flagged, with the failing sentences shown.
- What's on screen passes too. The fact cards that pop up during the reel and the summary card at the end are checked the same way. A card whose fact doesn't pass isn't shown.
The result: the jokes can be as loose as they like about the viewer, and never about the news.
In practice
Across 63 scripts, the checks looked at 882 factual claims: 542 in the scripts themselves and, since 23 October, 340 more on the on-screen cards. They caught 7 problems, all on cards, and none of the 7 reached the screen. Every claim that did reach the screen had passed its check.
An LLM checking an LLM deserves suspicion, and zero failures in 542 script claims could just mean a lenient checker. Two things push against that. The checker is a different model family, from a different provider, than the writer, and every verdict must quote the source, which code then looks for in the source text. And I tested it: I took 30 real scripts, changed one number in each (a deadline, an age, an amount, a year) and ran only the fact-check. It caught all 30, each with the right correction ("Minimum age is 18, not 23"), and raised no false alarm on any other sentence. Numbers are the easy case. A missing condition is harder, and the on-screen catches below are that kind. On top of the checks, I personally reviewed dozens of reels before they went out.
The joke pass added 138 sentences. 132 were about the viewer, people in general or Yvito, and needed no check. Six said something about the news, and all six were confirmed against a quote from the source. The best of them carries a deadline:
„პროფესორს, რომელიც შენს სახელს ვერ იხსენებს, შენს გასაცნობად 9 ნოემბრამდე აქვს დრო.“
"The professor who can't remember your name has until 9 November to get to know you." (reel)
The checker read it as a claim about the deadline and found it in the source: the recommendation letter and abstract are due by 9 November.
The catches were the kind a hurried human makes:
- A fact card called 20 November the application deadline. The source says that is the day selected participants are notified. The card was dropped. (reel)
- An end card said "anyone 18+, any profession". The source also requires one team member to be a student or graduate of Ilia State University, and one to speak English. The line was left off. (reel)
Good Georgian from models that barely speak it
Georgian has its own alphabet, about four million speakers, and very little of the web. Models write it, but they make the same mistakes again and again: calques from English, a wrong case after a verb, a tense that changes mid-sentence. Telling the model to "write naturally" doesn't fix that. What fixed it was treating the mistakes like bugs.
- An error catalog, confirmed by a native speaker. I collected the errors the models actually made and kept only the ones a native speaker confirmed. They became one short block of do and don't examples, grouped by error type. The same block sits in the story, punch-up and proofread prompts. A test keeps the three copies identical, and another checks that rows the speaker rejected never come back.
- Hard checks on every draft. At least 80% of the letters must be Georgian, the length must stay in range, and there are no dashes or stray markup. A draft that fails gets one follow-up turn with the reason, and fails loudly after that.
- A proofreader on a leash. A third pass may fix only grammar, spelling, punctuation and phrasing that reads as translated. Its answer is used only if code confirms that nothing else moved: the same paragraphs, the same on-screen directives, the same number of words within 10%. Otherwise the original stays and the reason is logged. Every fix is stored word by word, so the prompts are tuned from real corrections.
- A memory for jokes. The jokes of the last 30 days go back into the punch-up prompt, so the host doesn't repeat himself. Only jokes from scripts that passed the fact-check count.
Even the font got a fix: the comma was so wide that „კაი,“ read as „კაია“ on screen, so the comma, period and colon in the caption font were redrawn.
All of this layer exists because Georgian needs it. For English or another language models write well, skip the proofread pass with one setting. For another low-resource language, replace the catalog with your own.
Quality: picture, sound and variety
A correct script read over a static image is still a bad reel. The render is where cheap pipelines cut corners, and where this one spends its effort, all of it in code, so it costs nothing per reel.
- A host who acts, on a screen that keeps changing. The mouth is lip-synced to the voice, the host glances at the TV behind him and reacts after a punchline, and the camera pushes in on the line that matters or cuts to another angle, only ever at the end of a sentence. The TV changes picture every three to four seconds, a vision model checks each picture before it's used, and key facts pop out as cards, the first on the very first frame.
- One reel, four renders. Each platform gets its own version, with the share arrow pointing at that app's share button. The frames before and after the arrow are rendered once and joined by stream copy, so the four versions cost little more than one.
- Variety from a seed. Camera moves and reactions are randomised per reel from a seed: different every day, and exactly reproducible when one looks wrong and needs debugging. The writer also drafts three openings per reel and keeps the best, and recent jokes and share lines go back into the prompt so nothing repeats.
Before a reel reaches the reviewer, QA checks the file automatically: length, resolution, frame rate, colour format, bitrate, loudness, and a vision model looking at frames.
Automation: it feeds itself and grades itself
Feeding. Every three hours the system reads its sources: university news pages, the education ministry, scholarship portals, exchange programmes, as RSS, JSON or plain listing pages. A new source is a short entry in one YAML file. A source that keeps failing, or whose robots.txt says no, switches itself off. A model reads every new story and labels it: is it something you can still act on, who runs it, is it open to people in Georgia, how credible is it, and a score from 0 to 10. Picking is plain code: hard rules first (a real opportunity, a reputable provider, a deadline far enough away, never posted before), then the highest score.
Grading. After a reel goes out, the system checks on it one hour later, a day later, three days later, a week later, then daily for two weeks. It records views, average watch time, Instagram's skip rate and, from day three, YouTube's retention curve. Seventy-two hours after the last post, one line lands in Telegram:
Reel #N · YT 50% gone at X s · TT avg Y s (Z%) · IG avg Y s, skip Z% · hook H s
Every Sunday it ranks the last 30 days of reels on one score: the share of each reel people watched, weighted by views across platforms, blended with how late half the YouTube audience was still there. The openings of the three best and the three worst go into a file the script prompt reads: here is what held people, here is what lost them. The story pass also writes three openings for every reel, scores them against a rubric and keeps the best.
The same data tells me what to change in the engine itself. With 37 reels and 22 YouTube curves in, they agreed: half the audience was gone by about 8.6 seconds, almost all of it during the first two paragraphs, and about 61% of Instagram viewers skipped in the first three seconds. So the opening was rebuilt. The key fact now sits on screen from the very first frame, and something on screen changes about every 2.5 seconds for the first ten.
Automation: simple to run
The whole thing runs on one rented server, next to two other products, inside a systemd slice capped at 3.5 GB of memory and 2.5 CPU cores so it can never starve them. There are only two moving parts:
- A tick every ten minutes. A systemd timer runs one command that looks at the clock and starts whatever is due: an ingest, tomorrow's chain at 17:30, the stats sweep, the Sunday ranking. Every time and threshold lives in one config file per channel. If the server was down, the missed tick runs at boot. If a worker dies, the next tick restarts it, twice at most.
- A Telegram bot. It is the only interface. Reviews, retries, /pause and /resume, /status, a monthly /costs report of every paid model call. All state lives in SQLite, nothing in memory, so after a restart every old button still works, and a double tap never does anything twice.
There's no dashboard and no queue service. Failures arrive in Telegram with a Retry button, and silence means everything worked. Changing the channel's whole style is one line: when I decided the reels should be straight and informative instead of jokey, one switch changed the writing pass, the animation and the on-screen cards, and the rest of the chain ran as before.
The one human step is deliberate. The reels are about real deadlines, and a wrong date makes someone miss an application. So every reel reaches me 24 hours before its slot with five buttons: Approve, Post now, edit the caption, Regenerate (three times at most), Reject. If I never answer, it expires instead of going out unseen.
Keeping it simple is also what keeps it correct. The engine has more than 2,400 tests, and many replay a real incident; about 400 of them ship in the public repo, and the rest are tied to the Georgian channel. One incident: I posted a reel early with Post now, the code that frees an early reel's slot did exactly that, and within twenty minutes the scheduler had started a second chain for the same slot. Now a reel that has gone out keeps its slot, and a test replays that whole day tick by tick.
Keep what you need, skip what you don't
The core is the chain that makes a reel correct and gets it out: sources, assessment, pick, brief, script, fact-check, voice and render, review, publish. Everything else is a setting or a file, so the engine fits other channels without forking it.
| Part | What you can change |
|---|---|
| Style pass | Jokes, a plain informative tone, or your own prompt. One style object also sets the host's mood, the opening animation, cold opens, and which tones and vocal tags are banned. |
| Proofread and error catalog | Built for Georgian. Off with one setting for English; swap the catalog for another language. |
| Fact cards | A few per reel, or one for every deadline, age, amount and place. |
| Motion and camera | Push-ins, reactions, glances, camera angles and card timing live in JSON files. Set them calm or busy. |
| Weekly ranking | On for a channel with an audience to learn from, off for a one-off batch. |
| Sources and topic | A YAML file of sources and one assessment prompt that says what counts as a story. |
| Host, voice, platforms | The host is a set of drawings and a rig config, the voice is a TTS voice, and each platform can be switched on or off. |
Beyond one channel
The use I'd recommend: a business or a creator who wants their own steady stream of short videos from their news, articles or announcements. Like any content tool, it can be misused. I'm releasing it in good faith, and the default chain keeps a human approval and a source check on every claim.
Point it at job boards, city hall announcements, product releases or match results, and it makes that channel instead, in any language you can write a good error catalog for, or none at all if the models already write it well.
Drop any one of cost, quality or automation and you get slop, a bill, or a job. The engine is built so you keep all three.
The code is at github.com/francuza9/reelline. The 45-second demo shows the whole chain running on Yvito. Demos of this and my other systems, including an AI phone agent you can call right now, are at tskdev.org.