I Built a Faceless Video Factory That Remembers Which Content Pays

This is a submission for the Hacktoberfest Open-Source AI Challenge Week 2: Side Hustle

What I Built

Faceless Video Factory is a local-first pipeline that turns a single topic into a finished vertical short-form video — and, unlike every other tool I tried, it remembers which content actually made money and steers the next video toward it.

The problem: my side hustle is faceless short-form video, and every content tool out there is a script runner — same topic list, same output, run after run. Nothing learns. The half of the pipeline where money compounds (learning which topics paid) is the half everyone skips.

So I closed that loop with Backboard's persistent memory. Before each video, the "brain" recalls what earned money and picks the next topic accordingly. After each video, the revenue outcome is written back to memory. Run it twice and the second run is measurably smarter than the first. The person who pays for it is anyone running faceless content as a side hustle who's tired of guessing what to post next.

   recall what paid ──▶ [Brain] ──pick topic──▶ [Script] ──▶ [Assemble] ──▶ [Cashier]
        ▲                    (local LLM +        (local)     (FFmpeg)       (revenue)
        │                     recalled facts)
        └──────────────────── remember the outcome ───────────────┘

Demo

The learning loop, in one script (bash demo.sh): a cold run picks a topic blind, then two past outcomes get seeded into Backboard memory, then a warm run recalls them and steers the pick toward the $61.30 earner.

Run	Memory state	Topic picked	Why
1 (cold)	0 facts recalled	What I learned monetizing 40 short videos	No history — picked blind
2 (warm)	4 facts recalled	The side hustle nobody talks about: faceless video	Steered by the $61.30 earner in memory

The facts the brain learned from:

Past video	Views	Revenue	Signal
"Building an income stream that works while you sleep"	14,200	$61.30	🟢 high earner
"From keyword to video in under five minutes"	3,100	$3.10	🔴 underperformed

Each run renders a real 1080×1920 vertical MP4 (h264 + aac, espeak-ng narration, FFmpeg-generated gradient background — nothing downloaded). Run the whole thing yourself:

git clone https://github.com/Reggiebro/faceless-video-factory && cd faceless-video-factory
bash demo.sh            # cold -> seed -> warm: the learning in one script
python3 orchestrator.py # full pass: brain -> script -> video -> cashier

Code

The repo is MIT and public: https://github.com/Reggiebro/faceless-video-factory

Reggiebro / faceless-video-factory

A local-first faceless-video pipeline with Backboard persistent memory — an AI that remembers which content pays. Hacktoberfest 2026 Week 2: Side Hustle.

Faceless Video Factory — an AI that remembers which content pays

A local-first pipeline that turns a single topic into a finished vertical short-form video and tracks estimated revenue — and learns across runs which topics actually make money.

Built as a demo entry for the Hacktoberfest 2026 Open-Source AI Challenge Week 2: Side Hustle (DEV).

The idea

Most faceless-content tools are script runners: same topic list, same output, run after run. This one closes the loop:

                 ┌──────────────────────────────────────────┐
                 │  Backboard persistent memory + RAG        │
                 │  (survives across runs & sessions)        │
                 └───────┬───────────────────────▲──────────┘
          recall what paid│                       │remember the outcome
                         ▼                       │
   [Brain] ──pick topic──▶ [Script] ──▶ [Assemble] ──▶ [Cashier]
    (local LLM +           (local LLM)   (FFmpeg)       (revenue sim)
     recalled facts)

• Before each video, the brain recalls what earned money from Backboard memory and lets that steer the next topic.
• After each video, the outcome (topic, views, revenue) is written back to…

View on GitHub

The centerpiece is backboard/brain.py (~150 lines, readable end to end) — recall → pick → record. That's the whole idea. backboard/backboard_client.py is a pure-stdlib Backboard client (memory + RAG, no SDK dependency).

How I Built It

Open-source AI is the entire engine here — nothing closed does the work:

• Local inference: scripts are generated by an open-weight qwen model running in llama.cpp on my own machine (:8080), with a deterministic template fallback so the pipeline never blocks if the server's down.
• Open memory layer: Backboard's persistent Memory + RAG is what makes the factory compound — facts survive across runs and sessions. Backboard's hackathon credit covers Memory + RAG, so that's the one cloud call, and it's the free tier.
• Open tooling: FFmpeg for the render (gradients filter + libx264), espeak-ng for on-device narration, Python stdlib for the client.

The split — Backboard for memory, a local open-weight model for generation — isn't a workaround, it's the side-hustle thesis: the memory is what makes it smart, and the local model keeps the per-video cost at zero. No cloud token bill eating the margin.

Why Does Open Innovation Matter?

This is only possible because the two expensive halves of a content pipeline — long-term memory and text generation — both have credible open, local alternatives now. A closed memory API would reset every session and bill per fact; a closed LLM API would bill per token and put a ceiling on margin. Using an open-weight model on my own hardware plus Backboard's open memory tier means the whole thing runs at zero marginal cost per video, which is the difference between a side hustle that scales and one that just trades hours for a slightly-cheaper API bill.

Open innovation also meant I could read Backboard's memory + RAG behavior directly and build exactly the recall-steers-the-pick loop I needed, instead of waiting on a vendor to ship a "content memory" feature that probably never comes.

My Agent Session

Built largely with an agent harness driving the local llama.cpp model and the Backboard API — the brain's recall/pick/record loop, the stdlib client, and the FFmpeg assembler were all iterated on with the local model in the loop, which is also why the whole thing is offline-capable.

My First User

Not yet — no external user or paid customer yet. The demo above is my own run. Removing this from the prize consideration; the measurable result is the cold-vs-warm learning delta, not revenue.

Prize Categories

• Best use of Backboard.io — the project is built around Backboard's persistent memory as its core differentiator (the learning loop is the product).
• Best open-source / local-first AI — open-weight model + local inference + zero cloud token cost.

---

Has anyone else used persistent memory to make a content pipeline compound rather than just repeat? I'm curious whether the recall-steers-the-pick loop holds up at scale, or whether it starts chasing its own tail after a few dozen runs. What would you add to the feedback signal beyond revenue?