Programming a 24/7 channel has always meant sitting with the data and inferring what to run. Which shows held attention, which slots leaked viewers, what should move where. Then building next week's schedule by hand from those inferences.
You can automate that whole job now. Not just the guessing, the entire chain: what gets scheduled, how each video gets described, whether it passed its checks, where subtitles and ad breaks land.
That chain is broadcast playout automation: everything that turns a library of files into a linear channel, meaning one that plays on a schedule the way a TV channel does. Six stages sit between the library and the live stream, and linear channel automation means wiring all six. This article walks through each one: which AI tool does the work, where it plugs into FastPix, and where you should still keep a human.
TL;DR
Six things happen between your video library and a live channel: picking what plays, describing each video so you can find it, checking the files are not broken, adding subtitles, marking ad breaks, and measuring what worked. AI can do most of the work in each one.
On FastPix it looks like this. Your code reads the library, picks the running order, and writes it to a playlist. FastPix Cloud Playout plays that playlist as a channel. The AI tools write what they find back onto the same video, so nothing needs syncing. The channel's own analytics view tells you how it went, and that shapes the next lineup.
Two catches. The AI tools only run on uploaded files, not on a live source. And keep a human on rights, running order, and any subtitles that have to be legally accurate.
The 6 stages of a cloud playout workflow
Every channel playout system, cloud or on-premise, moves content through the same six stages. The AI playout workflow below follows that order. The names change by vendor. The sequence does not.
Stages two to five all work on files before they reach the channel, so they can run at the same time as soon as a video is uploaded. Stage one reads whatever they produced. It needs the quality check and the rights dates to be settled. It does not need every AI job to have finished.
On FastPix that maps cleanly. You upload a video and the AI jobs run on it, each firing a webhook when it is done. Your scheduler reads the library, picks an order, writes it to a playlist, and sends that to a Cloud Playout channel. Cloud Playout then reports, per channel, who tuned in and what held them.
Nothing in that chain is a separate system. One login, one record per video that collects everything the AI tools learned about it, one place the channel gets built. That is why this can be a single service rather than an integration project.
Which AI tool to use at each broadcast playout automation stage
Read this as a shopping list for playout automation software. Each row is one job, the tool that does it, where it plugs into FastPix, and what you get out of it.
| Function | AI tool you can use | Where it plugs into FastPix | What you get |
|---|---|---|---|
| Build the lineup | An LLM to shortlist and group candidates. Fitting them to the clock, and checking rights dates, stays in your code or a solver | The final order is written into a playlist, which the channel plays | The picking gets automated, the maths stays exact. A 24-hour day has to add up every time |
| Describe each video | FastPix In-Video AI reads what is *said*. Dalet Media Cortex, Veritone or Adobe Sensei label what is *seen*: objects, faces, scenes | Both write their labels onto the video's own record, so there is nothing to keep in sync | A library you can search, plus a safety flag you can check before airing. Skip it if your library is already well described |
| Check files before air | Interra BATON, Telestream IQ, Witbe | Reads FastPix's report on the uploaded file, then stores a pass or fail your scheduler checks | Broken files get caught on upload instead of on air, with nobody watching a review screen |
| Add subtitles | FastPix speech recognition for uploaded videos. A live speech-recognition vendor such as Ai-Media LEXI for live sources | Generated from an audio track on the video, then delivered with the stream | Accessibility coverage without paying a subtitling vendor per title. Uploaded videos only |
| Place ad breaks | Your ad server (Google Ad Manager or equivalent) | Ad breaks are a schedule entry type. Cloud Playout emits SCTE-35 markers in the HLS and DASH output | Choosing which ad plays stays where your campaign rules already live |
| Measure and feed back | Your own reading of the numbers, ThinkAnalytics for recommendations | Cloud Playout has a per-channel analytics view: sessions, unique viewers, watch time, session duration, top titles, top locations | The loop closes. Last period's numbers decide next period's lineup |
Everything in that third column uses the same cloud playout API key. No second dashboard to set up, no separate bill for the AI stages.
Most of that table is testable before you commit to any of it. A free account opens with $25 in credits and no card, which covers the upload, description and subtitle stages against your own files.
Stage 1: AI scheduling for linear channels
Treat the schedule as something you build, not something you edit. It gets generated, checked, shipped, and rolled back.
Split the job in two, because the halves need different tools:
- What to play. A judgment about content. An LLM does this well from your metadata and a brief.
- Where it lands. Arithmetic. Durations must fill the day exactly, rights dates are hard limits, ad breaks sit where sales sold them. Use a solver or a simple packer.
A model that is roughly right about 1440 minutes gives you dead air.
One FastPix constraint. Smart playlists fill themselves from date ranges only, ordered by upload date. Anything like "three unaired comedies under 22 minutes" is code you write, then save as a manual playlist in your own order.
That is the whole slow loop. A scheduled job, a selection function, and a commit. The selection function is where your rights model and editorial rules live, which is exactly where they should be.
The full walkthrough, including the metadata filters and the reorder calls, is in the AI channel scheduling guide.
Stage 2: Video metadata and media asset management
This stage gets oversold. Start with what a scheduler actually reads: length, genre, series and episode, rights dates, and when the video last aired. That is metadata, meaning the facts stored about a video rather than the video itself, and it comes from your CMS. None of it is AI-generated.
So the AI earns its place on two jobs, not on the whole stage:
- A safety gate. Your code checks the moderation flag before a video is allowed on air.
- Searching an old archive. Thousands of undescribed hours are unusable because nobody can find anything in them. Auto-generated summaries and lists of names fix that. If your library is already well described, this buys you little.
Two limits before you build on this.
FastPix In-Video AI works from what is said, so you get a transcript, a summary, and the names mentioned. It does not look at the picture. To search by what is seen, meaning objects, faces or scenes, you need a media asset management tool like Dalet Media Cortex, Veritone or Adobe Sensei. Its labels write onto the same video record.
That gap is what the FastPix Search Agent closes. It searches on what appears on screen as well as what was said, so the visual half stops needing a separate tool. See Video Search for what it covers.
And all of it runs on uploaded files. A live camera feed gets none of it.
Stage 3: Automated quality control for broadcast
QC is the easiest stage to automate and the hardest to trust. Machines are better than people at spotting broken files, and they stay good at it on hour six of a review shift.
You need two checks, not one. The first runs at upload and asks whether the file is sound. The second runs while the channel is live, because a channel breaks for reasons the file never showed: a rendition that never built, a source that stalls, an audio track that is valid and silent.
For the upload check, GET /on-demand/{id}/input-info tells you what actually landed: resolution, codecs, track layout. Moderation flags the content itself. Tools like Interra BATON or Telestream IQ go further on broadcast rules, and you store their pass or fail on the video so your scheduler can read it later.
Both checks are covered in the QC and captioning guide.
Stage 4: Automatic subtitles from speech recognition
Subtitles have the same shape as quality control. Accuracy is good enough to ship, and the errors that remain land somewhere a regulator cares about. Speech recognition slips on names, places and specialist words, which in news and sport are the words that matter.
One thing to know about the API. Subtitles come from an audio track, not from the video directly. So it is two calls: add the audio track, then ask for subtitles from that track with a languageCode and languageName.
The subtitle track is stored on the video rather than as a separate file you keep in sync. video.media.subtitle.generated fires when it is ready.
POST /on-demand/{mediaId}/tracks
POST /on-demand/{mediaId}/tracks/{trackId}/generate-subtitlesTwo limits worth designing around. This only works on uploaded videos, so subtitling a live source needs a real-time speech-recognition vendor sitting next to your encoder instead. And subtitle generation is not part of In-Video AI, which covers summaries, chapters, named entities and moderation. Different feature, different call.
Stage 5: Ad insertion and SCTE-35 break markers
This is the stage where AI can do more than teams will let it. Models read a scene and pick a good spot for a break. The problem is that the rules around ads are contractual. You cannot ship a model that gets them right most of the time.
Break markers are the simple part. They are just points in the schedule where the channel hands off. Which ad plays is your ad server's job, since it already holds the campaign rules, the frequency caps, and the rules about which brands cannot run back to back.
Cloud Playout emits SCTE-35 markers into the HLS and DASH output, covering pre-roll, mid-roll and post-roll, and a downstream server-side ad insertion service stitches the actual ads. An ad break is one of the entry types you can put in a schedule, alongside a video, a live stream, a slate card and idle filler. See configuring playout elements and ad breaks.
Stage 6: Channel playout analytics and the feedback loop
A dashboard is not a loop. You have a loop when last period's numbers change the next lineup rather than just sitting on a screen.
Cloud Playout reports per channel: sessions, unique viewers, total watch time, average session duration, top locations by city, and top titles by engagement with sessions and duration for each media ID.
The number to read first is sessions divided by unique viewers. A linear channel wins by becoming a habit, and that ratio is the only place repeat tune-ins show up. Total watch time is the one to distrust, because a channel accumulates it simply by running.
How to read each of them, and which signal gets missed most often, is in the playout analytics guide.
What the AI does, and what FastPix does
One boundary runs through all six stages. The AI makes a judgment. FastPix holds that judgment on the video record and acts on it when the channel runs. Nothing in between needs a translation layer, because the judgment is stored on the same video that goes to air.
| Stage | AI produces | FastPix does with it |
|---|---|---|
| 1. Scheduling | A ranked shortlist | Holds the committed order, plays it 24/7 |
| 2. Asset management | Summaries, names mentioned, visual labels | Stores them on the video, keeps them searchable |
| 3. Quality control | A pass or fail | Keeps the video off air until it passes |
| 4. Subtitling | A transcript | Attaches the subtitle track, ships it with the stream |
| 5. Ad insertion | A break decision | Carries the marker, hands off at the mark |
| 6. Analytics | An interpretation | Produces the raw numbers it reads |
That is the whole argument for doing this on one platform. Six stages, six different AI tools, one record per video and one API key underneath all of them.
Whether that holds for your library is not a question you can answer on paper. Most of it you can test today. A new account opens with $25 in credits and no card, which is enough to run uploads, subtitles and the description jobs across a slice of your catalogue and find out what your metadata is actually missing. For the channel itself, book a demo.
Where to keep a human in the loop
Automate all six stages. Keep a person on three decisions, where being wrong costs more than the work saved.
- Rights and clearance. A model reads the contract and is usually right. Usually is not good enough when the downside is a takedown. Let it extract, let a person confirm, then let code enforce it.
- Running order on news. Sequence carries meaning. Two stories are not neutral just because both cleared compliance.
- Subtitles that must be legally accurate. Speech recognition hits the bar on ordinary content and misses on news and live, which is what regulators check.
Then build three escape hatches before you ship the automation:
- Preempt. Push a live source into a running channel without touching the schedule.
- Freeze. Stop the scheduler writing, while playback carries on.
- Fallback. A video the channel cuts to when a source dies or the queue empties.
Build these as scheduler features and they will be down exactly when you reach for them.
Where to start
Do not build all six stages at once. Start with the slow loop: a scheduled job that reads your library, picks an order, writes a playlist, and sends it to a channel. That is roughly a sprint for one engineer, and it will teach you more about your rights model and your metadata gaps than any amount of design work.
Add the gates next. Quality checks before anything airs, a moderation flag your scheduler reads, subtitles on the recorded part of the schedule. Leave the analytics loop until last, because it needs enough aired history before last week's numbers mean anything.
The override levers come before all of it. They are the cheapest part to build and the only part you cannot add under pressure.
Build the first version against real content rather than a test file, because the gaps that matter are all in your own library. A card-free account with $25 in credits covers the upload, description and subtitle work straight away.
For the channel itself, book a demo and bring a real use case. Thirty minutes is enough to see a rundown built from content like yours.
Frequently Asked Questions (FAQs)
What is broadcast playout automation?
Running a channel from a schedule file instead of a person at a switcher. The schedule determines what plays when, where ad breaks occur, and what content to switch to if a source drops. Cloud playout puts this workflow behind an API, so you can manage it with code.
What are the stages of a playout workflow?
There are six main stages: scheduling, asset management, quality control, captioning, ad insertion, and analytics. AI tools can automate much of the work in each stage. Analytics can also feed back into scheduling, making the workflow a continuous optimization loop rather than a linear process.
Can AI run a 24/7 channel without a human?
AI can handle mechanical tasks such as content indexing, quality control, subtitle generation, and creating a first-draft schedule. However, it should not have the final say on rights, programming order, or legally important subtitles. A practical workflow lets the model suggest, your code commit the schedule, and a person approve decisions with legal or editorial consequences.
Does FastPix ship a scheduling product?
No. FastPix Cloud Playout focuses on building and delivering the channel, while the logic that determines what plays remains in your code. This lets you apply your own rights rules and programming logic instead of relying on a generic scheduler that may require extensive configuration.
