MUCKFLIX — The Digital Farm Showrunner

An autonomous AI showrunner that writes, films, QA-checks and publishes a brand-new claymation farm-comedy episode every day — powered by Qwen on Alibaba Cloud.

Comment 1

💡 Inspiration

Staying relevant online now means posting fresh short-form video every single day — but making it still needs a writer, a director, a camera, an editor and a budget. Today's AI video tools help, but they generate one-off clips: the character looks different every time, nobody checks whether the clip actually matches the idea, and there's no notion of a series. You can't run a show on that.

We wanted the missing layer: not a clip generator, but an autonomous showrunner — something that can run a daily, on-model, self-checking video channel by itself.

🎬 What it does

MUCKFLIX is an autonomous AI showrunner. Pick a character (or bring your own), pitch a one-line gag, and a pipeline of AI agents produces a finished, character-consistent claymation episode end-to-end — written, filmed, quality-checked and packaged — with no production team.

The public demo is a daily claymation farm channel, but the farm is just the demo — the engine is the product: point it at your mascot and it runs your daily show. Every generation streams live in a "Studio" wizard so you watch each agent work, and every finished episode keeps its receipts: a "How it was made" view that replays exactly how the agents built it, its blended cost, and its measured character-consistency score.

🛠️ How we built it

A LangGraph StateGraph wires 4 agents with a real conditional self-correction loop:

  1. Scriptwriter (Qwen3.7) — invents the day's absurd event and writes a punchy script.
  2. Production Director (Qwen3.7) — turns it into a keyframe prompt (the funniest frozen split-second) + a motion beat.
  3. Keyframe → Video → Vision — Qwen-Image paints the keyframe, HappyHorse image-to-video animates that exact still, and Qwen3-VL watches the finished clip and describes what actually happens. Episodes can be multi-shot micro-films (setup → escalation → punchline) stitched into one continuous video.
  4. Quality Control (Qwen3.7) — compares the real footage (via the vision description) to the script; on a mismatch it rejects the take and feeds the reason back to the Director, bounded by a MAX_REGEN budget guard. Nothing publishes unwatched.
  5. Packager (Qwen3.7) — writes the title + description and publishes.

Two signature techniques:

  • Keyframe-as-frame-0 for character consistency. We generate a still with Qwen-Image and animate that exact image with i2v instead of blind text-to-video, so the character's look is locked across episodes — and the keyframe doubles as a coherent thumbnail. An identity-lock check makes it measurable: a Qwen3-VL pass scores each keyframe against the canonical portrait (0.0–1.0) and rejects off-model takes; multi-shot episodes also score each shot against shot 0 to catch mid-arc drift.
  • Vision-grounded, self-correcting QA. QA reasons over what the video actually shows, not the intended script — closing the text↔video mismatch that plagues AI video.

Built on Qwen + Alibaba Cloud: Qwen3.7 (4 text agents), Qwen-Image (keyframes + portraits), HappyHorse i2v (video), Qwen3-VL (vision) via DashScope; deployed on Alibaba Cloud ECS, all media persisted to Alibaba Cloud OSS. Stack: FastAPI (SSE) · LangGraph · Next.js 14 · Docker.

🧗 Challenges we ran into

  • Character consistency. Text-to-video drifts every clip. Our keyframe→i2v technique fixed it — but the image endpoint accepts no reference image, so identity has to be enforced by scoring the result, not by conditioning the generator.
  • Text↔video mismatch. A model happily "succeeds" at the wrong thing. Grounding QA in a Qwen3-VL description of the actual clip is what made autonomous retakes possible.
  • Honest self-correction. On real infrastructure the loop is bimodal: an achievable gag is approved on take 1, and a gag the video model can't cast correctly is rejected on every take and shipped as a draft — because text-only feedback can't force an unconditioned generator on-model. So we leaned into the fail-safe (bounded cost, best-take selection, "nothing publishes unwatched") as the loop's real value, and documented it honestly rather than cherry-picking a lucky recovery.
  • Real unit economics. A cost meter that counts only text tokens lies. We metered image + video per unit so the per-episode receipt reflects the true blended cost.

🏆 Accomplishments we're proud of

  • Everything is backed by committed, reproducible evidence, not claims — real episodes on OSS with real blended costs ($0.30–$0.86), a committed identity-lock calibration, and a real unattended scheduler run (3 episodes, no per-episode human trigger, 2 auto-published + 1 QA-rejected draft).
  • A vision-grounded QA gate that genuinely gates (rejects off-model and unwatchable takes), a per-channel data flywheel with concurrent channels, and a 65-test offline suite.
  • Rounds of independent blind review consistently scored the honesty and real evidence as the standout.

📚 What we learned

  • Grounding decisions in what a vision model sees (not what a text model intended) is the key to trustworthy autonomous media.
  • The honest limits matter: an i2v generator you can't condition can be gated and measured, but not always corrected — knowing which is which is the difference between a demo and a system.
  • "Quality under a budget" only means something if you actually meter the expensive parts.

🚀 What's next

Per-creator channels, subscription + microtransaction monetization, a distributed lock/job queue for true multi-tenant scale, conditioning the generator on the portrait (to turn identity-lock from a gate into a closed loop), and even longer multi-beat story arcs — the same engine, scaled from one farm to every creator's daily show.

Built With

Share this project:

Updates