Letting agents produce our YouTube Shorts: about 250k tokens and $3 a video, from four real runs
Table of Contents
On the evening of October 12 I set a requirement for my YouTube channels: they should "keep improving and run on their own." We already had an autopilot for short videos, and that night we extended it into a channel autopilot covering six topic channels: three already scheduling videos, three getting ready to launch. The first fully unattended run is scheduled for the early morning of Monday, October 19.
This post is not about vision. It is about the ledger. Between the night of 10/12 and the morning of 10/13 we ran four videos for real and recorded the tokens for each. The numbers started out ugly and then got better, for a reason other than the one we first guessed.
Seven steps, once a week
Every Monday at 04:30 a scheduled task starts autopilot.mjs, which runs:
- metrics: read-only; views, completion rate and subscribers per video.
- comments: read-only; topics viewers ask for in comments.
- learn: one agent per channel, allowed to edit only that channel's rule file (PLAYBOOK). If no video has a completion rate yet, nobody requested a topic and I haven't rated anything, this step calls no model and is skipped.
- select: pick the week's topics. At most one comment request with enough people behind it, then fill from the topic family with the best median completion rate (a family needs at least 3 videos to be ranked), and keep one slot for an experiment.
- produce: one Opus worker per topic renders the video, then a separate Opus reviewer looks at a contact sheet and frame-by-frame stills and rules SHIP, FIX or BLOCK. Each video gets at most two render attempts; if the second still fails, it is marked held and left for a human.
- schedule: upload through the YouTube API as "private with a scheduled time," one per day at 12:00.
- report: write the weekly report and push it to Telegram, only between 8 a.m. and 10 p.m.
Some rules are hard-coded: the only writes to YouTube are uploads and scheduling. No changing visibility, no deleting videos, no replying to comments.
learn also has a ratchet. If a channel's rules changed last week and this week's median completion rate for public videos dropped by 10% or more relative to last week (with at least 3 videos in each week), the program swaps the rules back to the pre-change snapshot. The top section of each rule file holds my own words; it is append-only, learn's output is checked for that, and any violation restores the whole file.
Four real runs
First, how the dollars are computed: we use 100k tokens ≈ US$1.2, counting input, cache creation and output but not cache reads. That is API list price used as a yardstick to compare runs. The runs actually draw on a subscription; there is no separate bill.
Video 1, mechanical pencil (10/12, 20:32 to 21:03). First render 320k tokens, review 70k, sent back in round one: the spring's force was drawn in the wrong direction, and one line's meaning was unclear. The redo changed text only, 64k, and the second review, 60k, passed it. Total about 510k tokens, about US$6.2, 31 minutes. That is 3 to 5 times what a hand-dispatched worker used to cost us per video (40k to 110k), mostly because the worker read the entire handoff document from scratch every time.
Video 2, stapler (21:17 to 21:42). We cut the reading first: selection now hands the worker the scene list, principles and sources straight from the topic bank, and the worker and reviewer start in a clean temp folder without loading the whole workspace's settings. Total 388k, about US$4.65. The second review still said FIX: the sound effect and the on-screen state label were 2 to 3 frames apart. Held.
Video 3, folding umbrella (22:0x). We also cut the number of image views and the size of the frame stills. The first render only dropped from 230k to 222k, the total was 427k, and it was held again: two principle cards had 25 and 26 characters against a 22-character limit.
By then the conclusion was clear. An Opus first render has a floor of roughly 200k to 220k tokens (about 40k of output and 90k of tool results), and no amount of trimming the reading gets it to 120k. The three runs landed between 388k and 514k because all three were sent back in round one, which added a redo of 64k to 147k plus another review.
We had been optimizing the render. What was expensive was getting sent back.
Mechanical checks before review
Looking back at what the reviewer flagged, a whole class of problems needed no model judgment at all: cards over 22 characters, a source table without verification dates, a number marked "illustrative" whose qualifier went missing on screen, sound effects too many frames away from the state change, banned words.
So we wrote gates-script.cjs, a plain program that calls no model and renders nothing:
- Each principle card's explanation is at most 22 characters, counted exactly the way the reviewer counts.
- Rows in the source table marked general, illustrative, legendary or disputed must carry a qualifier on the matching card and description.
- Every source row has a YYYY-MM-DD verification date.
- Sound effect times, computed from the timing file, sit within 3 frames (24 fps, 0.125 s) of the state-label change computed from the model.
- Banned words are scanned in on-screen text and the upload description.
We tested it on the three finished videos. Umbrella: 2 FAILs, exactly the two cards the reviewer caught in round two. Stapler: all PASS (the program put the click 1 frame from "hits the groove"; the 2 to 3 frames the reviewer saw came from the recording's segment boundaries). Pencil: 1 FAIL, because it was made before the verification-date rule existed.
It plugs into the flow in two places: the worker runs it until it hits 0 FAILs before handing in, and the program runs it again before review. A FAIL goes straight back to the worker; it does not count as a review round and does not use up one of the two render attempts. We also added a split: if everything the reviewer flagged is text, the redo only edits text, re-renders and looks at the contact sheet once; the worker doesn't go back through the frame stills.
Video 4, trigger sprayer (10/13, 09:27 to 09:43). First render 228k, review 26k, SHIP in round one. Total 254k, about US$3, 16 minutes.
The numbers we now quote
| Case | Tokens | API equivalent |
|---|---|---|
| Passes first time | about 250k | about US$3 |
| Reviewer flags text, text-only redo | about 300k | about US$3.6 |
| Timing or cause-and-effect problem, full redo | 380k to 430k | about US$5 |
Six channels at 18 videos a week comes to an estimated US$60 to 90 equivalent, all inside the subscription. That is a sample of four; we will check again after the first full week on 10/19.
There is also a ceiling that isn't tokens: the YouTube project's daily upload quota of 10,000 units covers only about 6 uploads. On a day with 9 to upload, the extras go into a pending list and another scheduled task uploads them at 10:30 the next day. Publish dates stay as planned and only move if they have already passed.
Where the human comes in
Unattended doesn't mean nobody. The weekly report arrives once a week and the human does three things:
- Reply with one line of taste: which video worked, which was too slow, and why. It gets written into that channel's rule file, in the section for my own words, and every later video follows it.
- To cancel a scheduled video, reply with the channel name and date.
- Handle the report's to-do list. Week one already had one: reading comments needs the
youtube.force-sslscope, the original grant was read-only, and every comment read came back 403. Re-authorizing on 10/13 fixed it.
Videos marked held also stay put. They never publish themselves.
What we took away
The model's price was not the biggest lever. With the same Opus, moving the mechanical problems the reviewer always catches out of review and into a program saved more than switching to a cheaper model would have, without betting on quality. We also tested switching models and lowering reasoning effort; the results are in three cost experiments. How several agents share one GPU is in the render lock post.
Running a check that calls no model before the model gets involved is also how we approach AI security. UltraProbe runs a static check of your system prompt and tool descriptions against 25 defense vectors and returns in milliseconds, for free. If you run several Threads accounts, MindThread is the scheduling and reply tool we use every day ourselves.
FAQ
How much does it cost to have a Claude agent produce one YouTube Short?
From our four real runs: a video that passes review on the first try uses about 250k tokens, roughly US$3 at API list price. A text-only redo after review brings it to about 300k. A full redo for timing or cause-and-effect problems lands at 380k to 430k, about US$5. These are API-equivalent estimates (100k tokens ≈ US$1.2, excluding cache reads); the runs actually draw on a subscription, with no separate bill.
What was the biggest cost?
Redos, not the model's price. The first three videos were all sent back in the first review round, and the redo plus a second review pushed each run to between 388k and 514k tokens. We wrote the reviewer's most common mechanical complaints (card length, missing qualifiers, source verification dates, sound effects drifting from on-screen state, banned words) as a program that calls no model and runs before review, so the producing agent fixes them itself. The fourth video passed in the first round at 254k.
If the channels run themselves, what does a human still do?
Three things: reply to the weekly report with a line of taste (which video worked, which was too slow), which gets written into that channel's rule file; cancel a scheduled video by replying with the channel and date; and handle the to-do list in the report, such as re-authorizing an API scope. Everything from topic selection to scheduling is done by code and agents.