Video example is at the end.
Somewhere in a Railway datacenter in the Netherlands, a small worker process wakes up on a cron schedule. Over the next 2 minutes and 20 seconds it invents five video ideas, argues with itself about which one is best, writes a script, checks the script against my brand rules, generates a German voiceover and a music bed, renders a 30-second vertical video, and uploads it to YouTube.
Then it goes back to sleep for three days.
Total cost for the last days: $1.91. Five videos. My involvement: zero minutes. The videos are for Safebird, the agentic operating system we’re building for insurance brokers.
In my last article I argued that the founders winning right now build systems, not just products. This is what that actually looks like, a running process with a heartbeat. Here's exactly how it's built, including the version that failed, the actual prompts, and the guardrail that kills a run before it can spend my money on an off-brand video.
What the machine actually does
The agent is a pipeline of seven steps, and they come in three distinct tiers of predictability. Only three steps use an LLM, GPT-5.6 Terra Pro via OpenRouter, and each of those is a separate, small agent with its own persona, its own prompt, and its own temperature. Two more steps are generative but bounded: ElevenLabs synthesizes the voiceover and the music in single one-shot calls, with no feedback loop. And the remaining steps, the guardrail lint, the Remotion render, the upload, are plain deterministic code: same input, same output, every time.
Image
Notice the shape of it. Three creative steps, then a hard gate, then the production steps. The creative part is cheap (about $0.23 of LLM calls). Everything after the gate costs real money: voice synthesis, music generation, render compute. So the gate sits exactly where the money starts.
That ordering is not an accident. It's the whole design philosophy in one sentence:
Judgment before spend.
The version that failed (and why)
I didn't start here. Version one did what everyone does first: I let the LLM create the visuals.
The LLM authored raw Remotion TSX code for every scene, including layouts, animations, positioning, all of it. Then, because LLM-generated layouts are unreliable, I added a second LLM pass to look at rendered frames and grade them, a multimodal image-QA loop that regenerated scenes until they passed.
It technically worked. It was also a disaster:
- \~€6 per video: per-scene code generation plus the image-QA loop burned tokens like a furnace.
- Contrast issues, text overflow, visual artifacts: a model that writes brilliant German copy turns out to be a mediocre layout engine.
- Hard API failures: GPT-5.6 Terra Pro is a reasoning model, and reasoning tokens count against your max_tokens budget. One-shot generations of \~500 lines of TSX would hit 500 errors. The monolithic "generate everything in one call" approach didn't just look bad, it died at the API level.
The fix came from accepting a simple truth about what these models are actually good at:
LLMs are excellent at picking and filling. They're bad at pixel-perfect creation.
So I took the pixels away from the model. I hand-designed a library of ten parameterized scene templates: kinetic headlines, quote cards, chat mockups, stat callouts, a closer, everything built once, in code, on-brand by construction. The LLM's job shrank to the one thing it does reliably: pick the right template for each beat and write the copy that goes in it.
Cost per video dropped from \~€6 to \<$0.40. Quality went up, because the visuals are now consistent by construction instead of lucky by chance.
Image
The three agents and their actual prompts
Everyone asks about prompts, so here they are, the real ones, in production today. Each agent is one focused call with a narrow job. Notice what they have in common: a sharp persona, a tightly-scoped task, and a temperature tuned to the job.
Agent 1: Brainstorm · temperature 0.95
```
You are a sharp short-form video strategist for safebird.ai.
[guardrails injected here]
Your job: pitch FIVE genuinely different rough storyline ideas for a
30-second vertical YouTube Short. Each must be a distinct angle on how
AI assistants change a broker's daily work — capacity, speed of first
response, documentation, dormant Bestand potential, being present at 24/7, staying the trusted human while the assistant does the
Vorarbeit, etc. Vary the emotional register (aspirational, relief,
fear-of-missing-out, pride). Keep each thesis concrete and specific
to insurance broking.
```
One detail I love: before brainstorming, the agent pulls the titles of its own recent uploads from the YouTube API and gets told to avoid repeating those angles. The machine has a memory. It doesn't just generate, it remembers what it already said.
Agent 2: Rank · temperature 0.3
```
You are a ruthless creative director for safebird.ai short-form video.
[guardrails injected here]
Score each of the 5 ideas 0–10 on: hook strength in the first 2
seconds, clarity of the single takeaway, emotional pull for a solo
broker, and how well it can be told VISUALLY (kinetic type +
charts/shapes, no live footage). Pick the single best as winner.
```
Agent 3: Write · temperature 0.8 · the big one
```
You are a German short-form scriptwriter + art director for safebird.ai.
[guardrails + the full template catalog injected here]
Build a vertical Short (30fps) from the idea, ~25-35 seconds.
Structure: a 5-6 scene arc — hook → build → a calm "substance"
turn → CLOSER. Each scene = a VO line + a chosen visual TEMPLATE
with its copy fields. You DO NOT write any visual code —
you only pick a template and fill its text.
Rules:
- LANGUAGE QUALITY (critical): every VO line and every on-screen
text must be flawless, natural, idiomatic German — exactly how a
native speaker would say it out loud. Read each sentence in your
head; if it sounds constructed, translated, or awkward, rewrite
it simply. Short clear sentences beat clever-but-clunky ones.
- EVERY scene MUST have a spoken VO line — no silent scenes.
- The LAST scene MUST be the "closer" template.
- VO: calm deep voice (~2 words/sec). ~45-60 spoken words TOTAL.
Never speak "safebird.ai".
- Also write YouTube metadata (title, Du-form description, tags).
```
There's a real lesson in these three prompts, and it's not "prompt engineering." It's scope engineering. No agent does more than one cognitively distinct job. Divergence (0.95) is separated from judgment (0.3) is separated from craft (0.8). When one call tries to be creative, critical, and precise at the same time, you get the average of all three, which is mediocrity at scale.
How do you trust something you don't watch?
This is the question everyone asks about autonomous agents, and it has a concrete answer: you move your judgment into code, and you put the code before the money.
Between the writing agent and the first paid API call sits a deterministic linter, a plain regexes, no AI, that hard-gates everything the LLM wrote. It checks the spoken voiceover, every on-screen text field, and the YouTube metadata against my brand and compliance rules:
```
// real rules from guardrails.ts — a violation THROWS and aborts the run
GENDER_STAR = /\b[A-Za-zÄÖÜäöü]+[:*·/][Ii]nn?en?\b/ // no "Makler:innen"
PRICE = /(\d+\s?(€|eur|euro)|\b\d+\s?%|…)/i // no price/% claims
FAKE_PROOF = /(garantiert|marktführer|testsieger|…)/i // no invented proof
AVOID_PHRASES = [/in deiner marke/i, /unter deinem namen/i]
// and my favorite, learned the hard way:
if (/safebird\s.\sai/i.test(vo))
→ violation: "spoke raw domain safebird.ai"
// because the text-to-speech voice mispronounces it.
// On-screen text may show it. The voice may never say it.
```
That last rule is the kind of detail you only discover by shipping. No framework gives you "your TTS butchers your domain name." You find out, you wince, you encode it, and from then on the machine never makes that mistake again. Every guardrail in that file is a scar from something that went wrong once. That's what production prompts actually look like: half creativity, half scar tissue.
And the failure mode is deliberately cheap. If the linter throws, the run aborts after \~$0.23 of LLM calls, before voice, music, or render spend a cent. A skipped cycle costs pennies. An off-brand public video costs trust. A skipped cycle is cheaper than a bad video, so the system is designed to skip.
On top of that, uploads default to unlisted, live and linkable, but not pushed to subscribers, until I flip one environment variable to public. Full autonomy, but staged trust. You don't hand the keys over on day one; you watch the machine behave, then widen its permissions.
The two halves never talk to each other
One more architectural choice worth stealing. The agent runs on Railway. My admin dashboard runs on Vercel. They have no network connection to each other at all, they share exactly one thing: a database.
Image
When I press "Start now" in the dashboard, it inserts a row into a trigger table. The worker polls that table every 30 seconds, claims the row, runs the pipeline, and writes back per-step timing, status, and exact cost. The dashboard renders whatever the database says. If the worker dies, the dashboard shows a stale heartbeat within 30 minutes. No webhooks, no queues, no service mesh, a table.
This is the boring kind of architecture that lets you sleep. Any part can be down, redeployed, or rewritten without touching the others.
The numbers, because numbers are the point
Image
The $0.37 breaks down to roughly $0.23 of OpenRouter LLM calls (the three text agents) plus \~$0.14 of ElevenLabs (voiceover + one music generation). And because OpenRouter returns the exact cost of every call in its response, these aren't estimates, the runtime collects real numbers from every step and writes them to the database. The dashboard screenshot at the top of this article isn't a mockup.
For comparison: the last time I paid a freelancer for short-form video editing, a single 30-second clip cost more than this machine will spend in one year.
What this is really about
Zoom out and the video itself is almost beside the point. A 30-second Short for German insurance brokers is not going to break the internet. What matters is the shape of the thing:
- Three small agents instead of one mega-prompt including divergence, judgment, and craft separated and temperature-tuned.
- The LLM constrained to what it's good at, picking and filling with pixels owned by code.
- Judgment encoded before spend, and a deterministic gate that makes the cheap failure mode the default one.
- Staged trust, with unlisted video first, public when confident.
- Boring decoupling, with two platforms sharing nothing but a database table.
None of these are AI tricks. They're engineering decisions. And that's the actual claim behind "build systems, not just products": the leverage isn't in the model. The model is a commodity, everyone has the same one I do, fifteen cents of it at a time. The leverage is in the machine you build around the model: the constraints, the gates, the memory, the metering, the failure modes you designed on purpose.
A product needs you to market it. A system markets itself: one video every three days, while you sleep, for less than a coffee costs.
The 4-hour work week isn't about working less. It's about spending your hours building the machine, so the machine can spend its hours building the rest.
This one took weekend to build and one painful €6-per-video lesson vto get right. It has now paid for itself, in the only currency that compounds: hours I never have to spend again.
Build the machine that builds the machine.