We Handed an Entire YouTube Channel to an AI Agent

I run a YouTube channel called Sounds of Rain in Old Japan. An Edo-period tenement row, a Heian temple, a Meiji-era Western-style residence — historical Japanese scenes where it simply rains. Ambient videos for work, study, and sleep.

The channel has one unusual property: almost the entire production process is run by an AI agent. Image generation, video generation, rain-audio selection, stretching clips into multi-hour videos, writing the Japanese metadata, translating it into 14 languages, generating thumbnails, uploading to YouTube. My job is to send parameters from my phone and to type “Go” at the right moments.

It started by hand in March 2026; today, a single WhatsApp message is enough to produce a video. This article is the map of the whole thing. The individual incidents — the limits of local LLMs, the night $23.82 evaporated, the week we swapped video engines twice in four days — each have their own article.

It began as manual labor

The first videos were made entirely by hand. Generate images in the Nano Banana Pro web UI and download them one by one; turn them into 15-second clips with Kling AI; clean up royalty-free rain audio in Adobe Audition; edit loops in Adobe Premiere to stretch them to 30 minutes. The repository still holds the files from those days, exactly as they were:

Generated Image March 08, 2026 - 4_56PM.jpg
Generated Image March 08, 2026 - 4_58PM.jpg
Generated Image March 08, 2026 - 5_06PM.jpg
Generated Image March 08, 2026 - 5_10PM.jpg
Generated Image March 09, 2026 - 8_28PM.jpg
Generated Image March 09, 2026 - 8_40PM.jpg
Generated Image March 10, 2026 - 9_10AM.jpg
Final_Generated Image March 10, 2026 - 9_10AM.jpg

Browser download names, committed without so much as a rename. You can read them as a diary: four attempts on the evening of March 8, two more the next night that went nowhere, and on the third morning a single image that finally earns a Final_ prefix. Three sittings across three days, for one still image. I remember thinking this was honestly not sustainable — while also genuinely enjoying just looking at what came out.

The funny part: the very first commit of this “manual era” already contained CLAUDE.md — a 270-line operating manual written for an AI to read. A document whose intended reader is a machine, sitting in the same commit as images a human saved one by one from a browser. The factory blueprint existed from day one; the entire workforce was me, clicking.

The turning point was GTC 2026

After a few hand-made videos, I flew to San Jose for NVIDIA GTC 2026. What I brought home — after some hesitation at the venue’s gear shop — was a DGX Spark (all duties and taxes properly paid). I decided it would become the production studio.

This is that “studio” today. The gold box between the monitors is the DGX Spark. On the left screen, VSCode running on the Spark has the amaoto project open — a brewery scene image, as it happens. Everything described below happened on this desk.

The other encounter also happened at GTC. OpenClaw, an agent runtime, was the hot topic among attendees that week, and at a tent called ClawBar I tried installing it together with NVIDIA staff. Load a local model, send a command from WhatsApp, and the list of browser tabs open on the Spark comes back to your phone. That little demo led directly to the idea of driving a video-production pipeline from WhatsApp.

Back home, I ran git init on the Spark and started replacing my Premiere work with scripts, piece by piece: crossfades, stabilization, fade-in/out, audio loop joins — all reimplemented in ffmpeg. It was the hardest part of the whole build, and it became the innovation that gave me my time back.

A video compresses down to seven fields

The single most effective design decision in the automation was not any script — it was compressing the input. One video, it turns out, is fully described by this:

scene_id   edo_nagaya
era        Edo
place      tenement row
time       morning
season     spring
rain       gentle drizzle
director   kinoshita

Everything downstream — the image prompt, the video prompt, the rain-audio choice, the title, the description, the translations, the thumbnail — derives from these fields. The moment the input fits inside a text message, every control surface becomes possible. You can drive a video factory from WhatsApp not because the pipeline is clever, but because the input is seven fields.

The director parameter deserves its own article — it is about giving an image model the persona of a film director, and it is the single biggest discovery of the project (article in Japanese).

WhatsApp becomes the control panel

In practice, operations ran on roughly this vocabulary:

Go          Cancel      Pick 1 / Pick 2 / Pick 3
Approve     Regenerate  Same prompt
Ok          Resume <scene_id>

Here is the real screen. I send seven parameters, the agent echoes back its interpretation and offers “Go / Cancel,” and three minutes after my “Go,” the first image of an Edo sake brewery arrives. Throughout all of this I am touching nothing but a phone.

About a dozen words, most of them one syllable, and a video channel runs on them. It looks elegant, and I genuinely like this part. But five months of operation taught me that the actual engineering never lived in the beautiful part.

What actually consumed the time was this kind of thing:

• The agent’s instruction file was being silently truncated at 12,000 characters — and what gets cut is the end of the file, which is exactly where the newest rules live, the ones you just wrote to fix the latest problem. The warning was printed on screen in every session; it went unread for seven weeks.
• The instruction file existed in two places, and one of them is read by nobody. When your edit changes nothing, the cause is either “you edited the file nobody reads” or “you edited the right file past character 12,000” — and the symptoms are identical.
• If the WhatsApp socket sits idle for three-plus hours, outbound messages silently vanish afterward. No error anywhere. The work succeeds and only the notification evaporates, which destroys the instinct that “no reply means failure.”
• We curated a command allowlist through five careful generations of backups — and in the version we were running, it was never enforced at all. The real defense was the human pressing “Go.”

All of it is unglamorous. And that unglamorousness, I have come to believe, is the true texture of operating AI agents. Quietly missing infrastructure outnumbers spectacular hallucination by a wide margin.

The two incidents, in their own articles

Five months of operation produced two incidents that deserve stand-alone write-ups.

The first is the defeat of the local models. Having bought a DGX Spark, I naturally wanted the agent’s brain to run on a local LLM. Over 72 hours I went from Nemotron to Qwen3 to Qwen3.6 — until Qwen3.6 reached the point of reporting the elapsed time of a script it had never executed — and then switched to Claude. The first command after the switch just worked, which produced a strange mixture of relief and grief. The full story: “Can Local LLMs Run a Real Agent Workflow?”

The second is a cost accident. The agent registered, on its own, a cron job to check a multi-hour ffmpeg process every five minutes, re-loaded a 10 MB session each time, and burned $23.82 in one night. The most important part of that incident is not the amount — it is that the agent correctly decided mid-way to stop the cron, got the stopping method wrong, and had no way of discovering its mistake. The postmortem is public: “How Our Automation Agent Burned $23.82 in One Night.”

That cron incident is where Resume <scene_id> in the vocabulary above comes from. The hours-long assemble step was cut away from the agent entirely; a human gives one more push when it is done. Giving up on full automation improved both the cost and the architecture — and that design decision became the foundation for everything that followed.

Shorts: moving the human gate

The long-form pipeline has three human approval gates in the middle: pick one of three images, approve the video prompt, approve the clip. The Shorts pipeline we built at the end of June (for YouTube Shorts and Instagram Reels) deleted all three.

The gate moved to the very end instead. Twelve steps — image generation, AI image selection, video generation, audio selection, assembly, metadata, 14 translations, an Instagram caption, a thumbnail, upload — run unattended, and the result lands in YouTube Studio as a private draft. A human reviews it there and presses publish.

Here is one video this pipeline produced unattended, in about twelve minutes:

The gates did not disappear; they moved. Three mid-process approvals became one post-process review. A pipeline with gates in the middle cannot run unattended; a pipeline with one gate at the end can.

Why we re-bet on Shorts in the first place — the long-form videos that never reached beyond Japan despite 56-language localization, and the first Short that cleared 1,000 views — is its own story (article in Japanese).

The work that remains human

In August, I reviewed the videos the Shorts pipeline had been producing, all at once in YouTube Studio, and wrote eleven defects into a file called modification.md. The breakdown says a lot about where this project now stands:

Cause	Count
Physically impossible water (fountain-like splashes, etc.)	4
The cat moves too much (tail briefly becomes two, etc.)	4
Architecture that does not exist	2
Metadata contradicting the footage	1

Zero infrastructure failures. No SIGKILL, no OOM, no auth errors. The machinery is now completely stable, and every remaining problem is aesthetic, physical, or historical — a lantern flame too large, a cat with two tails, a scene that is “somehow just gloomy.”

That last one matters. “The scene simply looks gloomy, not fun to watch” — there is no technical defect, nothing is broken, and yet it is not good. No automated check exists for this, and none is coming. That is precisely why the one review gate at the end remains a human job.

The QC file reads less like a bug tracker and more like director’s notes addressed to a machine. Full automation did not remove the human; it moved the human to the end of the line and changed the job title from operator to director. How we designed the work that stays human is its own article (in Japanese).

What five months taught us

1. Everything fails silently. The truncated instruction file, the vanishing notifications, the era-mismatched rain audio — not one of them raised an error. A pipeline that crashes when it breaks is a pipeline you can trust; almost nothing in this stack did us that courtesy.

2. Where you put the human is the architecture. Not how many gates — where. The long-form line with three mid-process gates could not run unattended; the Shorts line with one end gate could. The permanent fix for the cron incident was also “a human gives one more push.”

3. Domain knowledge is the final moat. Cats reached Japan around the Nara period — by ship, guarding Buddhist sutras from mice — so no cats in Jōmon or Yayoi scenes. An engawa is a ground-floor element, so “a veranda on the second floor of a teahouse” is a contradiction. A lantern’s flame belongs inside the lantern. None of this lives in any model, and it is the entire difference between this channel and the thousand other AI rain channels.

4. Depending on external models means maintaining forever. Mid-operation, Kling AI’s pricing changed overnight and we swapped video engines twice in four days. Prompts change meaning when the engine changes. That story: “The Day Kling Raised Its Prices” (in Japanese).

I have written elsewhere about treating video as an asset — and this channel itself, running in production rather than as a demo for months on end, has become an asset for us: it generates real operational data about AI agents every single day.

If you are considering building AI agents into your own operations, feel free to get in touch. We can speak from experience — including all the unglamorous parts described above.