George Tskitishvili
← All projects

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

Every step is automatic except one tap
  1. SourcesRSS, JSON, web pages
  2. Assess · AIlabels + 0–10 score
  3. Pick · coderules, then score
  4. Brief · AIfacts, or not stated
  1. Writer agentplain facts only
  2. Style agentadds 2–3 jokes
  3. Proofreadgrammar only
  4. Fact-checkclaims vs the source

fails: back to the step that broke it

  1. Voice + animationlip-sync, Remotion
  2. QAfile, sound, frames
  3. One human tap24 h before the slot
  4. Four platformsYT, TikTok, IG, FB
  5. Stats + Sunday rankingbest and worst openings

every Sunday back to the writer

AI modelMeCode and services

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:

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.

  1. 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.
  2. 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.
  3. 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.
  4. 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.
  5. 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.
  6. 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:

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.

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.

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:

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.

PartWhat you can change
Style passJokes, 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 catalogBuilt for Georgian. Off with one setting for English; swap the catalog for another language.
Fact cardsA few per reel, or one for every deadline, age, amount and place.
Motion and cameraPush-ins, reactions, glances, camera angles and card timing live in JSON files. Set them calm or busy.
Weekly rankingOn for a channel with an audience to learn from, off for a one-off batch.
Sources and topicA YAML file of sources and one assessment prompt that says what counts as a story.
Host, voice, platformsThe 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.