Hypeoslav - AI Media Holding

Challenge

Co-founded Hypeoslav as an AI-native media holding, multiple content channels producing image, text, and audio content at scale. The economics only work if production cost per post is near zero. Manual workflows across Midjourney, ChatGPT, ElevenLabs, and publishing tools were taking 2, 3 hours per post. That wasn't a media business; it was a manual production studio.

Discovery

Breaking down the content production workflow revealed that every step was mechanical: write prompt and then generate image, write caption, generate voiceover, assemble post and then publish to channel. None of these steps required human creative judgment once the brief was defined. The bottleneck wasn't creativity. It was orchestration.

Options Considered

1. No-code automation tools (Zapier, Make), evaluated. Couldn't handle the multi-step AI API calls, error handling, or conditional routing between generation services.
2. Custom web dashboard: rejected. Editors didn't want another tab to manage; the interface needed to be where they already worked.
3. Telegram Bot as the control interface + Python backend pipeline: chosen. Editors already used Telegram; bot commands gave instant access to the pipeline from any device.

Decision

Python orchestration layer connects to all AI APIs. Telegram Bot API is the interface: an editor sends a content brief, the pipeline fans out to the appropriate generation services in parallel, assembles the result, and either auto-publishes or presents a preview for approval. Each channel type (image-heavy, text-heavy, audio) has its own pipeline variant.

Implementation

Integrated Midjourney (via Discord API automation), DALL·E and Recraft for image generation, ChatGPT and Gemini for captions and scripts, and ElevenLabs for voiceover. Each service has its own async handler with retry logic and fallback routing, if Midjourney is slow, the pipeline switches to Recraft automatically.

Post assembly merges the generated assets into platform-native formats for Telegram channels, YouTube Shorts, and Instagram. Scheduling is handled via a queue that distributes posts across optimal publishing windows. YouTube AdSense monetisation was set up across the video channels.

Outcome

Content production time dropped from 2, 3 hours to under 5 minutes per post. Multiple channels run in parallel with one operator. The infrastructure handles the creative pipeline end-to-end. The human role is brief definition and quality gate, not production execution.

Pipeline in Blender

An intermediate stage of the pipeline, captured in Blender. The scene is assembled automatically: images are placed and aligned, the avatar is composited on top, and a smoke effect runs over the shot (an early version of it). Every image and every scene in the clip came out of the LLM stage. Subtitles were laid on separately, outside Blender.

Animated Subtitles

Subtitles are animated karaoke-style, with the current word highlighted as it is spoken. Blender had no workable subtitle support, so the merge was done in ffmpeg: Blender put out a clean render and the subtitle track was burned on in a separate pass. The styling was reworked later on. A drop shadow was added, and the font was extended with the glyphs it was missing so it could carry other languages, Korean and Japanese included. The original version broke on those.

Multilingual Intros and Viral Covers

Generated intros in several languages, shown alongside the cover images that front the videos. Voice was the part that took the most searching: a run of local models was tested, Kokoro-based ones and the Facebook releases among them, before ElevenLabs was picked as the main voice tool.

The cover images get their own prompt set. Rather than describing a picture, the prompts encode what already worked, taking apart reference thumbnails that had gone viral and carrying their patterns over into the generated ones.

Localised Script Files

The file structure the pipeline works from: rewritten scripts plus their metadata, one set per language. The constraint that shaped it is that a video has to come out at roughly the same length whatever language it ends up in, so the scripts are adapted to fit a duration rather than translated line by line. A literal translation drifts, some languages run visibly longer than others at the same word count, and the timing against the visuals falls apart.

Avatar Generation

Avatars are generated in ComfyUI across a set of models, and the pipeline pulls video out of it through an integration rather than calling a paid service. That kept the cost down, external generation services were the single largest line item, and it also put generation quality under direct control: the model, the settings and the number of steps are dialled per channel instead of accepting whatever a vendor endpoint returns.

Telegram Control Bot

Running the pipeline 24/7 meant it had to be steerable from a phone, so the control surface is a Telegram bot. Work is multi-threaded: tasks go into a queue and slave workers pick them up as they free up, rather than one job blocking the line behind it.

Video generation runs stage by stage, and the stages that need a human eye stop for one. The bot reports that a stage is done and moves on to other work instead of idling. The operator opens the result from Yandex.Disk, which is why the check works from a phone, and answers accept or redo, with the option to change the prompt before the retry. The finished video is uploaded to Google Drive.

The bot also carries the failure path: a task that fails is reported with its error instead of dying quietly in the queue, and it can be restarted straight from the chat.

The full step-by-step run, with the intermediate results approved one stage at a time.

Distributed Workers

The worker side of that queue. Several executors connect to one task server, take whatever is next - generate text, transcribe audio, generate images - and run it. At peak five machines on my home network were working at once, a Steam Deck among them, each running a client that pulled tasks from the server and did them.

Desktop Visual Editor

Fixing a single bad frame through a chat bot is awkward, so the visual side got its own desktop client. It opens a project, reads it, and lays out every scene image next to the prompt that produced it. A prompt can be rewritten and that scene regenerated on the spot, without rerunning the pipeline or hunting for the frame in a folder.

Trend Monitoring

Picking what to make next needed data rather than taste, so a separate microservice in Go watches a list of added channels and collects what has taken off there. Those videos become the reference pool the briefs and the cover prompts are built from, which is where the viral patterns described above actually come from.

The watcher itself, running over the tracked channels.

Raising the YouTube API Quota

Monitoring at that scale runs into the YouTube API quota, so we applied to Google for a higher limit on grabbing statistics. The application went through. The project was put on hold not long after, so the raised quota never got to be used at full stretch.