A friend of mine runs a successful YouTube channel around regenerative ecosystems. He used to record the videos, and then spent more time on everything that came after than on the recording itself. Writing the title. Rewriting the title. Drafting a description that includes the right keywords without sounding like it was written for a machine. Pulling frames from the video, testing which one works as a thumbnail. Adding text and design elements to the thumbnail. Filling out tags. Uploading. Checking the upload didn't break.
That is a few hours per video, every video, forever. The recording is the creative part. The rest is a workflow, and workflows are exactly where AI automation shines.
So we built one. A Django application that takes a recorded video and its transcript, and moves it through publication with AI agents doing the work at each step. He stays in control, but he stops doing the parts that don't need him.
Why an agent, not a script
You could write a script that calls an LLM once and asks for a title. That gets you something. It usually doesn't get you something good, because a good title depends on what the video actually says, what performs on that channel, and what the creator's voice sounds like.
The difference between a script and an agent is that an agent has a job and can take multiple steps to do it. It can read the transcript, look at what the previous ten videos on this channel were titled and how they performed, generate several candidates, evaluate them against each other, and come back with a recommendation and its reasoning.
That is what we built. Each stage of the pipeline is an agent with a defined role, its own context, and its own tools.
The pipeline
The workflow starts when a video lands in the system with its transcript. From there it moves through a series of stages, and each stage is owned by an agent.
The first agent reads the transcript and builds a structured understanding of the video. What is it about, what are the key moments, where are the natural chapter breaks, what is the hook in the first thirty seconds. Everything downstream depends on this, so it runs first and its output is passed forward.
The title agent takes that understanding, plus the channel's history, and generates candidates. It doesn't produce one title. It produces several, ranked, with a short explanation of why each one might work. My friend sees all of them.
The description agent writes the body copy, pulls the timestamps for chapters from the transcript analysis, and assembles the tags. Descriptions are formulaic enough that this one is close to solved.
The thumbnail agent is the interesting one. It pulls candidate frames from the video, evaluates them for the things that matter in a thumbnail (a face, clear expression, visual contrast, no motion blur, no mid-blink), and proposes the best options. It can also compose text overlays on top of the selected frame. It shows the options side by side.
The final agent handles publication. It authenticates with the YouTube API, uploads the video, sets the metadata, applies the thumbnail, and schedules or publishes.
The human stays in the loop
Every stage stops and waits for approval before the next one runs.
This was not a compromise. It was the point. A system that runs end to end without a human is a system that will eventually publish something wrong to an audience of thousands, and nobody will notice until the comments arrive.
The admin interface shows the pipeline as a visual progression. Each stage has a state: waiting, running, needs review, approved, failed. When an agent finishes, the stage moves to needs review and my friend sees exactly what it produced. He can approve it, edit it, or reject it and send the agent back with feedback.
That last part matters. Rejection is not just a no. He can say "the title is too clickbaity for this channel" and the agent regenerates with that constraint applied. The feedback becomes part of the context for the next attempt.
Over time, patterns emerge in what he rejects and why. Those patterns get folded back into the agents' instructions, and the approval rate goes up.
What the interface actually does
The admin panel is a Django app with a live-updating view of every video in the pipeline. Progress is pushed to the browser as it happens, so when the thumbnail agent is working through frames, he sees it working. There is no refresh button.
Each stage renders its output in a form he can actually judge. Titles as a ranked list. The description as it will appear on YouTube, not as raw text in a textarea. Thumbnails as thumbnails, at the size they'll be seen, in a grid.
The system also keeps a full record of what each agent did and why. Which frames it considered and rejected. Which titles it generated and how it ranked them. This is not a debugging feature. It is how you build trust in a system that makes decisions on your behalf. If you can't see the reasoning, you can't tell the difference between a good decision and a lucky one.
What this actually is
Strip away the YouTube specifics and this is a general shape: a repeatable multi-stage process, work that requires judgment at each stage, and a human who needs to stay accountable for the output.
That shape shows up everywhere. Content review. Claims processing. Candidate screening. Report generation. Anywhere a person is currently doing something skilled but repetitive, and doing it the same way every time.
The pattern that works is not full automation. It is agents that do the work and a human who approves it, with an interface good enough that approving takes seconds instead of minutes. That is where the time comes back.
My friend now spends about ten minutes on post-production per video. He records, he uploads, he approves four screens, and it's live.
Want help with this?
If you have a process in your business that looks like this, the same approach applies. We build these systems. Get in touch and tell us what your workflow looks like.