Inside the Avatar and Lipsync Pipeline We Actually Run

Script in, clip out, no manual stitching

A script is not a video. Somewhere between the words on the page and a finished talking head clip, a real pipeline has to generate an avatar, put the right voice in its mouth, sync the lips to the audio, and assemble the result into something publishable. I did not want that chain to depend on me sitting at a keyboard running five separate tools in the right order every time. So I built it as an actual pipeline, with named versions, not a folder of one-off experiments.

The chain has version numbers because it has been rebuilt more than once

The real work here shows up as a specific, tagged sequence: ranking-reels, creatify, ai-video, fullscreen-avatar, avatar-v3, lipsyncs-v2, ffmpeg, and steel-playwright browser automation. Read that list in order and it tells you the actual shape of the pipeline.

• avatar-v3 means this is not the first attempt. Two earlier avatar approaches got replaced before this one stuck.
• lipsyncs-v2 means the sync step alone went through its own revision, separate from the avatar generation step.
• ffmpeg is where the raw generated assets get assembled and encoded into a deliverable file, not left as disconnected clips.
• steel-playwright is browser automation doing the parts of the job that only work by driving a real browser session, not an API call.

That is a pipeline, not a script. It is tied to my own ranking-reels product, which means the fullscreen avatar format was not built as a generic demo, it was built to ship inside a real product with real output on the other end.

The tool stack underneath Spielberg

A separate build documents the concrete stack this runs on: Creatify for the avatar and lipsync layer, ElevenLabs for voice, and Remotion for programmatic video assembly, all wired together with the fleet's agent-memory system so state persists between steps instead of getting lost between tool calls. It started as an internal build, not a client-facing announcement, before it became the pipeline Spielberg runs today.

Each piece does one job and only one job:

• Creatify handles the avatar generation and lipsync.
• ElevenLabs handles the voice, separate from whatever voice track Creatify would default to.
• Remotion assembles the pieces into a finished, programmatically composed video instead of a manually edited one.
• Agent memory carries state across the chain so a failed step does not force a restart from zero.

It is registered, not improvised

This pipeline is not a side project living in someone's local folder. creatify-video-pipeline is a real, registered build in my build registry, grouped under the video-pack capability pack alongside sibling tools I built for the same problem space: vidforge, narrate-ai, clip-anonymizer, video-pipeline-assets, yt-transcripts, and yt-living-pipeline. Being part of a named pack means it is discoverable and reusable by any agent that needs a video capability, instead of getting reinvented every time a new video task shows up.

Why the version numbers matter more than the tool names

Anyone can name-drop Creatify, ElevenLabs, and Remotion. What actually proves a pipeline works is that it survived being rebuilt. avatar-v3 and lipsyncs-v2 exist because v1 and v2 of the avatar step, and v1 of the lipsync step, were not good enough and got replaced. That is what a real production pipeline looks like: not a single clever demo, but a chain that has been torn apart and rebuilt at the exact points where it broke, until script-to-clip stopped being a manual job and became something Spielberg runs the same way every time.

What I actually check before I trust a clip

I do not sign off on a talking head clip because the avatar looks fine at a glance. I check the same three points every time: does the lipsync hold up past the first three seconds, where most sync drift shows up, does the assembled ffmpeg output match the script word for word with no dropped lines, and does the voice track from ElevenLabs match the energy the script was written for instead of a flat default read. Any one of those failing sends the clip back into the pipeline instead of out the door. That checklist is short on purpose. A pipeline this versioned does not need a long list of things to verify, it needs the same short list checked every single time.