The Agent-Run YouTube Channel: How Three Layers of Agents Publish 100 Videos
There’s a real YouTube channel - about a hundred videos, published on a daily schedule - that I didn’t write, record, edit, upload, or schedule. AI did the research. AI built the videos. An autonomous agent published every one. My involvement in a batch of fifty videos is about ten minutes.
The video above walks through the whole machine on camera. This guide is the written version: the architecture, layer by layer, so you can stand up your own - and the rules that keep a system like this from becoming the AI slop everyone’s rightly worried about.
One boundary before anything else. The channel belongs to Fear-me-not, a CBT-based app that helps kids face their fears through play. The app is not AI - it’s built on evidence-based CBT. What the agents run is the content pipeline: the YouTube channel that teaches parents the science. Two different things. Keep that distinction the whole way through.
Why build a channel this way
I’m one person running several companies. A channel that needs a hundred researched, produced, published videos was either impossible - or a function I could staff with agents. This is the Agent-Staffed Function pattern applied to content: one accountable human, specialized agents, written rules, and a feedback loop, running a whole function that would otherwise need a team.
The architecture has three layers. The order matters - the first layer is what makes the other two defensible.
Layer 1: The research engine
Nothing gets made from a model’s memory. Everything starts with a knowledge base that agents build from real sources - peer-reviewed psychology papers pulled through Semantic Scholar, clinical literature, credible articles - and every source has to pass credibility standards before it gets in.
Then, for every single video, an agent curates a dedicated set of sources - three to fifteen of them - into one NotebookLM notebook. One notebook per video. For a fifty-video batch, that’s hundreds of sources, mapped, attached, and logged.
And the rule that keeps the whole thing honest: some topics people genuinely search for don’t have dedicated clinical studies. The system doesn’t pretend they do. Those scripts are framed on the closest real evidence, and there’s a standing written rule: no fabricated statistics, ever. If there’s no honest number, the video doesn’t get a number.
That’s the difference between generated content and researched content that happens to be produced by machines. The video is grounded in its sources, not in whatever a model happens to remember.
Layer 2: The video factory
Each video has a written generation prompt - topic, angle, what to emphasize, and a visual style chosen per playlist (paper-craft for deep-dives, soft and cute for little-kid topics, anime-styled for teen topics, whiteboard for science explainers). An agent drives NotebookLM’s Video Overviews to render it - narration, visuals, structure - grounded in that notebook’s sources. (It’s the same agent that publishes in Layer 3, operating the tool click by click - not NotebookLM running itself.)
The system writes each video’s title, description, and tags too, and the title rule is baked into the generation step itself: write titles the way the target viewer would actually type the search at 2am, not something clever. The searchable version comes out by default because the rule lives in the prompt, not in someone’s head.
Thumbnails are generated the same way, following a short written playbook: one focal point, an honest number if there is one, three or four big words, no clutter. The machine makes the image; the human owns the rules it follows.
Layer 3: The publishing agent
A finished video still needs uploading, titling, describing, tagging, playlisting, and scheduling - fifty times per batch. Bulk uploaders and schedulers exist. The difference here is that it isn’t a tool a person drives - it’s an autonomous agent (mine is called Hermes, living on a Mac mini) running the whole chain itself, off the same pipeline that made the video.
It works two ways, and the split is the design lesson. For the creative step, it drives a browser the way a person would: opens NotebookLM, generates the video from the notebook, downloads the file. But for publishing - the part that has to be exact, fifty times in a row - it doesn’t click around YouTube Studio at all. It talks straight to YouTube’s official Data API: pushes the video and thumbnail, sets the title, description, tags, playlist, audience setting, and publish schedule - and then verifies its own work: did the video process, are the tags right, is the thumbnail attached, is it in the correct playlist, will it publish when it should. Then the next one.
Deterministic work goes through deterministic interfaces; browser-driving is reserved for the surfaces that have no API. That single split is most of the reliability.
And one gate that never moves: nothing goes public or gets scheduled without human approval of the exact package. The agent does the grind; the human owns the release.
”Isn’t this AI slop?”
It’s the right question, especially for content about children’s mental health. Here’s the answer, and each part maps to a layer above.
Slop is what you get when a model generates content from nothing, at volume, with nobody accountable. This system is the opposite on all three counts: every video is grounded in a notebook of vetted sources (Layer 1), there’s a written rule against invented statistics (Layer 1), and one accountable human owns the quality bar, reviews the work, and changes the system when something’s off (the approval gate in Layer 3).
The automation isn’t automating the thinking. It’s automating the grind - uploading, formatting, scheduling - so one person can afford to put properly researched answers in front of people searching for them. An AI pipeline is only as trustworthy as the rules you build into it. So build the rules in.
What “ten minutes” really means
Honesty about the number: ten minutes is my involvement in a batch’s production and publishing pass - approvals and spot-checks. The strategy layer - choosing topics, writing the quality rules, auditing what worked, changing the system between batches - is real work, done by me with agents, and it took real hours. That’s exactly the division the pattern predicts: strategy stays human, grind goes to agents. The ten minutes is only credible because the hours happened.
The one gap: Shorts
The system produces long-form. Vertical Shorts are the gap - and when NotebookLM shipped a Shorts format, I tested it six times on this exact channel to see if it closed it. It didn’t, yet. The full test and the prompt playbook that came out of it: NotebookLM Makes YouTube Shorts Now - I Tested It 6 Times.
Build your own version
The pattern transfers to any content function: (1) a grounded research layer with credibility rules written down, (2) a production layer where per-item prompts carry the strategy, (3) a publishing agent that uses official APIs for the exact work and verifies its own output, (4) a human approval gate in front of anything public. Start with the rules and the research layer - they’re what everything else inherits.
Two ways to take it further. To learn it and build your own, the community has the buildable version — the layer-by-layer construction lesson and the operations manual my publishing agent actually runs (stage gates, verification checklists, exception handling), with the specifics stripped out so you can hand it to your own agent: Built, Not Hired’s community. Or, if you’d rather start from a complete, ready-to-run system — the rules files, the research directives, the generation templates, and the publishing scripts, assembled and documented — that’s the Agent-Run YouTube Channel Blueprint.