Media & Publishing Systems

Editorial Context

The audio file lands in the shared drive at 11 PM. By the time the editor opens it next morning, it needs to be transcribed, time-coded, cleaned for filler words, subtitled in three languages, loudness-normalized for broadcast, and queued for QA. The old answer was a stack of contractors. The better answer is a stack of agent skills — each doing one job cleanly, with a human reviewing the package before anything ships.

This post maps the media and publishing workflow to the skills available in the Media & Publishing Systems collection on Agent Skill Exchange. The goal is not to automate away editors. It is to build a content ops pipeline that is evidence-based, reproducible, and fast enough to run on every piece of content — not just the ones with budget for manual production passes.

The core insight: content ops is a production discipline, not a generation problem

Most AI content conversation centers on generation — write this post, draft that script. That is the wrong frame for media teams. The more valuable opportunity is in the production layer: what happens after the raw content exists. That layer is full of deterministic, high-volume, repeatable tasks where mistakes are expensive and quality is measurable. Transcription accuracy, subtitle timing drift, loudness compliance, broken publish links — these are engineering problems, not creativity problems. Agent skills handle engineering problems well.

The media workflow that benefits most from agents is not “AI writes a podcast.” It is “AI turns a recorded podcast into a correctly timed, translated, loudness-compliant, chapter-tagged asset ready for the editor’s final pass.” That distinction matters for how you build, what you trust, and where you keep humans involved.

Stage 1: Transcription — the foundation of everything downstream

Every text-dependent step in a media workflow depends on transcript quality. Get this wrong and errors compound through subtitles, chapters, and translations. The two tools that anchor this stage are Whisper and WhisperX.

Whisper (OpenAI’s open-source ASR model) produces strong base transcripts across accents and audio qualities. Its weakness is word-level timestamp alignment — it gives you text with rough sentence timings, which is not precise enough for subtitle sync.

WhisperX solves that with forced phoneme-level alignment, giving you word-by-word timestamps accurate enough for subtitle rendering without manual correction on most audio. For media teams dealing with dense interview content or technical terminology, WhisperX with a domain-specific vocabulary file is the right starting point.

A well-built transcription skill will:

• Accept audio or video input and extract the audio track if needed
• Run the appropriate model based on language detection
• Return transcript with word-level timestamps and confidence scores
• Flag low-confidence segments for human review rather than silently guessing

Low-confidence segments are the gotcha. A skill that swallows them silently produces clean-looking output with buried errors. A skill that surfaces them produces a transcript with inline review flags — which is what editors actually need.

Stage 2: Subtitle alignment and format export

Once you have word-level timestamps, subtitle generation becomes a mechanical task: group words into readable line lengths, respect reading-speed targets (typically 17–21 characters per second for broadcast, looser for online), and export in the format the platform requires (SRT, VTT, TTML, or EBU-STL).

A subtitle alignment skill that works well handles three things most tools skip:

1. Speaker change detection — a new subtitle block should start when the speaker changes, not just when the line is full.
2. Gap enforcement — subtitles need a minimum gap between blocks (usually 2 frames / ~67ms) or decoders merge them. This is the most common source of “correct” subtitles that look broken on playback.
3. Platform-specific constraints — YouTube, Netflix, and broadcast have different max line lengths and character encoding rules. The skill should take a platform parameter and handle those differences automatically.

Internal link opportunity: teams that already use browser automation skills can wire subtitle upload directly into the platform’s management interface after QA passes, closing the last manual step in the subtitle loop.

Stage 3: Translation — scope it correctly or skip it

Translation is where media agent stacks need the clearest human checkpoint. Machine translation quality has improved dramatically for common language pairs (EN→ES, EN→FR, EN→DE), but degrades significantly for complex domain terminology, idiomatic speech, and markets where tone is culturally load-bearing (marketing content in Japanese, formal Arabic, Brazilian Portuguese vs. European Portuguese).

The right role for a translation skill in a media workflow is draft production, not final copy. The skill produces a translated subtitle file, flags segments where proper nouns, brand names, or terminology diverged from a provided glossary, and routes those segments to a human reviewer. A skill that produces a “complete” translation without review flagging is optimistic; one that produces a draft with structured review notes is useful.

If your volumes justify it, build a glossary file into the skill’s references directory — a simple TSV of source terms and their approved translations per market. This single addition cuts review cycles by 40–60% on technical or branded content.

Stage 4: Loudness normalization

Loudness standards are the kind of compliance requirement that humans do not catch by ear reliably. The difference between -14 LUFS (Spotify target), -16 LUFS (YouTube), and -23 LUFS (EBU R128 broadcast) is real but subtle on casual monitoring. Platforms reject or auto-adjust non-compliant files — and auto-adjustment sounds bad.

A loudness normalization skill wraps ffmpeg with the appropriate LUFS targets and true-peak limits, runs a two-pass measurement-then-process workflow, and returns both the normalized file and a measurement report showing integrated loudness, loudness range, and true peak. The report is what matters for audit: it proves the file met spec before upload.

Common gotchas to include in any loudness skill:

• Music-heavy content clips differently than speech — normalization targets for music beds should be handled as a separate config option
• Stereo downmix affects LUFS measurement; the skill should measure the final distribution format, not the edit master
• Short clips (<30 seconds) are exempt from integrated loudness measurement under EBU R128 — use momentary or short-term values instead

Stage 5: Transcript cleanup and chapter generation

A raw Whisper transcript includes filler words, false starts, and run-on sentences. For podcast show notes, article summaries, or searchable transcripts, these need cleaning. A transcript cleanup skill handles:

• Filler word removal (um, uh, you know, like — configurable per use case; leave them for verbatim legal transcripts)
• False start removal with context checking (remove “I think — what I mean is” but keep “she said — and I quote”)
• Paragraph restructuring at speaker changes and topic shifts

Chapter generation is a separate skill that takes the cleaned transcript and identifies topic boundaries. The output — a list of timestamps and chapter titles — feeds directly into YouTube chapter tags or podcast player chapter markers. When chained with the WhisperX word-level timestamps from Stage 1, chapter markers accurate to within one or two seconds are achievable without human editing of the timestamps themselves.

Stage 6: Publishing QA — the step teams skip and regret

Publishing QA is often treated as a post-mortem discipline: you find the broken link or missing metadata after someone complains. Building a pre-publish QA skill into the workflow flips that. Before content goes live, the skill checks:

• All internal and external links in the article or show notes resolve (no 404s)
• Required metadata fields are present (title, description, tags, canonical URL, og:image)
• Image alt text is populated
• Subtitle files match the video duration within an acceptable tolerance
• Loudness report file exists and passes spec

The skill returns a structured pass/fail/review verdict for each check — not a summary sentence. Structured verdicts integrate cleanly into editorial dashboards and give the human reviewer a clear, bounded list of what to fix rather than a vague “looks good” or a wall of text to parse.

Teams that build this QA skill often discover it catches an embarrassing volume of issues on the first run. That is not a sign the skill is over-sensitive; it is a sign the existing manual process had soft spots. Running it consistently tightens the whole pipeline.

What still needs human review

Being specific about this matters. Agent skills in this stack handle mechanics well. They do not handle editorial judgment. A human reviewer should remain responsible for:

• Transcript accuracy on proper nouns and specialist terminology — especially names of people, products, and places that are not in training data
• Translation tone and market fit — particularly for marketing, brand, and culturally sensitive content
• Chapter title quality — the agent will segment accurately; the titles it generates may be accurate but dull
• Final approval before live publish — the QA skill produces a verdict, but the decision to publish belongs to a person

Building these human checkpoints into the workflow explicitly — as approval gates, not as “the editor can check if they want to” — is what separates a production-grade agent pipeline from a demo that works until it doesn’t.

Building the stack on ASE

The Media & Publishing Systems collection brings these workflow stages together. Each skill is designed to chain with the next: transcription output feeds subtitle alignment, alignment feeds translation, loudness normalization runs in parallel, and QA closes the loop.

For teams building custom skills in this space, these existing ASE posts are useful references for the craft of skill design itself:

• The Gotchas Section: The Single Most Valuable Part of Any Skill — the loudness and subtitle gotchas above are exactly what goes in a gotchas block
• Progressive Disclosure: Why the Best Skills Split Content Across Multiple Files — a skill like subtitle alignment with platform-specific config benefits from a references/ directory for platform specs
• The Best Verification Skills Share One Trait: Clear Evidence, Not Vague Confidence — the publishing QA design principle (structured verdicts, not vague summaries) comes directly from this approach

The real value: reproducibility at scale

The argument for building a media agent stack is not speed, though speed improves. It is reproducibility. Manual production workflows produce inconsistent results across operators, time of day, and workload pressure. An agent stack produces the same checks, the same measurements, and the same structured output every time — whether it is processing one episode or fifty.

That consistency is what makes the human review at the end of the pipeline actually useful. When the agent has already caught the mechanical issues, the editor’s time goes toward judgment calls. That is a better allocation of human attention than catching that the loudness report is missing or the subtitle file has the wrong frame gap for the third time this month.

Content ops is becoming an evidence-based production discipline. The teams building these skills now are the ones who will publish more, with fewer errors, and with reviewers who spend their time on the things that actually require human judgment.

Explore the full Media & Publishing Systems collection on ASE to see which skills fit your current workflow, and check out the skill creation guide if you want to contribute a skill to the catalog.