Ten Agents, One Newsroom: Orchestrating an Autonomous Video Factory

Most "AI video" tools are a single prompt wearing a UI. This one is built like a small production company: every job that a human short-form team would divide among a researcher, an editor, a social manager, a QA reviewer and a showrunner is given to a dedicated agent with its own brief, its own tools, and its own craft knowledge. The design question was never "which model" — it was "who owns what, and how do they hand off?"

01The org chart, not the model

The pipeline is a directed hand-off between ten agents. A source URL enters at the Finder and a scheduled post leaves at the Uploader; along the way the Planner briefs the Editor, the Finishing Editor gates the render, and — the part that makes it a system rather than a script — the Manager writes what it learns back into a file the Finder reads on the next run.

02What each agent owns

Single responsibility is enforced at the agent boundary. No agent both selects and renders; no agent both renders and judges its own output. That separation is what lets each one carry a focused prompt and a narrow toolset.

03A provider-agnostic brain

Every agent calls the same two helpers — call_tool() for structured output against a schema, and call_text() for free-form text — and neither knows or cares which model answered. The provider is chosen in config.yaml; agent code never changes when you switch from a paid Claude endpoint to a free one.

The load-bearing feature is automatic fallback. The single worst failure mode in an unattended pipeline is silent degradation: the primary provider gets rate-limited, the call quietly returns a dumb default, and the day's clips ship broken while a perfectly good provider sits unused. So the LLM layer builds a chain — primary first, then each configured fallback that has an API key — and walks it on rate-limit or error.

PROVIDERS = {
  "openrouter": ("OPENROUTER_API_KEY", ".../api/v1", "llama-3.3-70b-instruct"),
  "groq":      ("GROQ_API_KEY",       ".../openai/v1", "llama-3.3-70b-versatile"),
  "gemini":    ("GEMINI_API_KEY",     ".../v1beta/openai/", "gemini-2.5-flash"),
  "nvidia":    ("NVIDIA_API_KEY",     ".../v1", "llama-3.3-70b-instruct"),
  "ollama":    (None,                 "localhost:11434/v1", "llama3.1"),
}
# primary provider first, then every fallback that actually has a key
chain = [primary] + [f for f in cfg.fallbacks if has_key(f)]

04Craft as prompt-injected skills

An LLM told to "pick a good clip" produces random results. The difference between random and deliberate is 24 written craft playbooks in factory/skills/ — markdown on hooks, storytelling, pacing, sound design, captions, thumbnails, SEO, engagement and monetization — loaded directly into the relevant agent's prompt. The Finder reasons with a battle-tested selection brief (drama-first picking, the 3-second test, "start where the drama lands," loop-back endings for rewatches); the Editor reasons with editing and sound-design playbooks.

Keeping craft as editable markdown rather than baked-in code means the system's taste can be tuned without touching a line of Python — and it's what makes the output feel authored instead of arbitrary.

05The loop that learns

A pipeline that produces the same average clip forever is a tool. A pipeline that gets better is a system. Two mechanisms close the loop:

• Per-run: the Manager reads real analytics — views, retention — decides what actually won, and writes that verdict to a learnings file the Finder consults before scoring the next episode's candidates.
• Weekly: the Trainer studies the top-performing Shorts in the niche (not just your own) and updates one craft playbook, so the whole team levels up instead of standing still.

The feedback isn't a vague "do better" — it's a concrete artefact (an updated file) that a specific downstream agent already reads. That's what makes the improvement compound rather than evaporate.

06The quality gate that watches

Agent 8, the Finishing Editor, exists because generative pipelines fail in visually obvious but programmatically invisible ways. It reviews every finished render the way a picky human editor would and catches captions covering a speaker's face, black or frozen frames, dead-air gaps, clipped or too-quiet audio, and wrong durations. Cheap problems (a quiet mix) it auto-fixes; broken clips it blocks from ever posting.

Crucially, a block doesn't thin the schedule: the produce step renders-to-target with QA backfill — a blocked clip's slot is automatically refilled with the next-best candidate. The gate raises quality without ever leaving a hole in the day's plan.

07Never silently zero

Unattended means the failures happen while you're asleep, so the system is built to refuse two outcomes above all: shipping something broken, and shipping nothing. Beyond the QA gate and provider fallback:

And it all runs free by default: transcription is local (faster-whisper), the voiceover uses free Edge TTS, and the background-music library is pure synthesis, so the output is safe to monetize. Paid Claude is offered as the "best quality" option, not a requirement.

Nirmit K. Tripathii

AI/ML Engineer & Researcher building agentic LLM systems, multimodal pipelines and production AI. Open-sourced this project under MIT after a month of nights and weekends.