No publish without a verified MP4: inside the quality gate
Every time Autoretto prepares a release, the last thing between the render and the channel is a set of checks. We call it the quality gate. It is not glamorous, but it has kept a lot of broken videos off the internet. The gate runs after all the pieces are done: the Suno audio, the Gemini artwork, the optional Sora motion, the final render. It runs before anything can move toward YouTube. You can think of it as a bouncer who actually reads the IDs. No names on the list, just the real artifact.
The gate starts with the audio itself. An AI generation might look fine in a file listing. It can have the right name and the right size. That tells us nothing. We actually decode the file. We read the samples into memory. We check that the duration matches what we asked for. We look for silence, clipping, or a weird loop point. We also make sure the sample rate is what we expect. A file that claims to be 44.1 kHz but decodes at 22 kHz will sound wrong when it reaches the viewer. If the decode fails, we don't try to fix it. We throw the run back to the start.
The next check is sync. Autoretto renders a beat-synced video. That means the visual changes land on the beat. We don't just trust the renderer to line things up. We take the audio waveform, find the transients, and compare them to the timeline we used for the video. We know the beat positions because we extracted them during the generation step. The visual cuts are supposed to hit those positions within a small tolerance. If the drift is more than a few frames, we reject it. A video that feels off-rhythm is slop, even if it looks pretty. On a music channel, rhythm is the product.
Then comes the MP4 artifact. The upload step will not run unless an MP4 file exists in the configured storage. But existing is not enough. We probe the file with ffprobe, or an internal equivalent. We verify the container, the codec, the resolution, the duration. We confirm the file size is in a sane range. We compute a checksum and store it with the release. The publish state is not allowed to advance until that checksum matches a file that has been fully written and closed. We have seen cases where a process died right after creating a zero-byte file. The gate catches that. We have also seen a file that was still being written when the pipeline tried to move on. The gate waits for the size to stabilize.
The rule is simple: no verified MP4, no publish claim. We will not log a release as published because we think it probably uploaded. The YouTube API has to return a video ID. And before we even start the upload, the local artifact has to pass every check. If anything fails, the release goes back into the queue. There is no way to manually mark it as good. That would defeat the purpose. We want the state machine to be honest. Every time a release moves from one stage to the next, it leaves a record. The record says what was checked and when.
People sometimes ask why we bother. The answer is that automated channels have a habit of producing garbage if you let them. A broken render, a garbled audio file, or a video with no visual movement will still consume time and storage. It might even get published if the pipeline is sloppy. We want the channel to stay clean, and we want the performance data to mean something. If a video makes it to YouTube, it should actually be the thing we intended to make. We also want the learning loop to work. If we let slop through, we will learn the wrong lesson about what works.
The gate also helps us learn. When a release fails, we record why. Those failures feed back into how we prompt Suno, how we generate the visual timeline, and how we set thresholds. A release that keeps failing due to sync drift might need a different visual script. A release that fails audio decode might need a different generation seed. The gate is not a wall. It is a measurement. It tells us where the pipeline is weak, and we can strengthen it. Every successful release is one that has been decoded, synced, and verified as a real MP4. That is the honest version of done.