diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 11f6d26..1357ebb 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -191,6 +191,7 @@ published manifests/media and send playback events to Core.
 Technical reference, as needed:
 
 - [Flow engine](docs/flow_engine.md): templates, execution, retries and debugging.
+- [Audio description](docs/audio_description.md): steps, outputs, providers and host policy.
 - [Prepared analytics](docs/analytics_sessions.md): setup and data lifecycle.
 - [Webhook delivery](docs/webhook_delivery_outbox.md): signed lifecycle events.
 - [Encoding boosters](deploy/encoding-booster/README.md): optional remote compute;
diff --git a/README.md b/README.md
index 1329327..b67fc01 100644
--- a/README.md
+++ b/README.md
@@ -20,8 +20,8 @@ and publish videos — with your media in S3-compatible storage that you control
 
 - **Manage:** organize videos into folders, invite your team, and replace a
   video without changing its public embed.
-- **Publish:** resumable uploads, adaptive HLS, posters, subtitles, and
-  customizable player settings.
+- **Publish:** resumable uploads, adaptive HLS, posters, subtitles,
+  [audio description](docs/audio_description.md), and customizable player settings.
 - **Integrate:** embed with web components, iframe, React, or Vue; automate
   with the video API and signed webhooks.
 - **Understand:** see views, drop-off, and viewing sources in your dashboard,
diff --git a/assets/js/app.js b/assets/js/app.js
index 14d3eaf..2b93a2f 100644
--- a/assets/js/app.js
+++ b/assets/js/app.js
@@ -28,6 +28,7 @@ import topbar from "../vendor/topbar"
 import "@lottiefiles/lottie-player"
 import { ChartHook } from "./hooks/chart"
 import { cdn } from "./upload"
+import { FileMenuHook } from "./hooks/file_menu"
 
 let selectedEmbed = null
 
@@ -717,6 +718,7 @@ const liveSocket = new LiveSocket("/live", Socket, {
     draggable: DraggableEmbedHook,
     thumbnail_preview: ThumbnailPreviewHook,
     auto_open_file_picker: AutoOpenFilePickerHook,
+    file_menu: FileMenuHook,
     preserve_scroll: PreserveScrollHook,
   },
   uploaders: { cdn },
diff --git a/assets/js/hooks/file_menu.js b/assets/js/hooks/file_menu.js
new file mode 100644
index 0000000..1b74394
--- /dev/null
+++ b/assets/js/hooks/file_menu.js
@@ -0,0 +1,89 @@
+export const FileMenuHook = {
+  mounted() {
+    this.onClick = (event) => {
+      const trigger = event.target.closest("[data-file-menu-trigger='true']")
+      if (trigger && this.el.contains(trigger)) {
+        this.isOpen ? this.closeMenu() : this.openMenu(event.detail === 0)
+      } else if (event.target.closest("[role='menuitem']")) {
+        this.closeMenu()
+      }
+    }
+    this.onOutside = (event) => {
+      if (!this.el.contains(event.target)) this.closeMenu()
+    }
+    this.onKey = (event) => {
+      if (!this.isOpen) return
+      if (event.key === "Escape") {
+        event.preventDefault()
+        this.closeMenu(true)
+      } else if (event.key === "Tab") {
+        this.closeMenu()
+      } else if (["ArrowDown", "ArrowUp", "Home", "End"].includes(event.key)) {
+        event.preventDefault()
+        const items = [...this.panel.querySelectorAll("[role='menuitem']:not(:disabled)")]
+        const current = items.indexOf(document.activeElement)
+        const next = event.key === "Home" ? 0 : event.key === "End" ? items.length - 1 :
+          current < 0 ? (event.key === "ArrowDown" ? 0 : items.length - 1) :
+          (current + (event.key === "ArrowDown" ? 1 : -1) + items.length) % items.length
+        items[next]?.focus()
+      }
+    }
+    this.onScroll = (event) => {
+      if (this.isOpen && !this.panel?.contains(event.target)) this.positionMenu()
+    }
+    this.onResize = () => this.closeMenu()
+    this.el.addEventListener("click", this.onClick)
+    this.el.addEventListener("keydown", this.onKey)
+    document.addEventListener("pointerdown", this.onOutside)
+    document.addEventListener("scroll", this.onScroll, true)
+    window.addEventListener("resize", this.onResize)
+  },
+
+  updated() {
+    this.closeMenu()
+  },
+
+  openMenu(focusFirst = false) {
+    this.trigger = this.el.querySelector("[data-file-menu-trigger='true']")
+    this.panel = this.el.querySelector("[data-file-menu-panel]")
+    if (!this.trigger || !this.panel) return
+
+    // Keep the menu clear of the narrow sidebar's scroll clipping and viewport edges.
+    this.panel.style.display = "block"
+    this.positionMenu()
+    this.trigger.setAttribute("aria-expanded", "true")
+    this.isOpen = true
+    if (focusFirst) this.panel.querySelector("[role='menuitem']:not(:disabled)")?.focus({ preventScroll: true })
+  },
+
+  positionMenu() {
+    const anchor = this.trigger.getBoundingClientRect()
+    if (anchor.bottom <= 0 || anchor.top >= window.innerHeight) {
+      this.closeMenu()
+      return
+    }
+    const menu = this.panel.getBoundingClientRect()
+    const inset = 8
+    const rowRight = this.el.parentElement.getBoundingClientRect().right
+    const left = Math.max(inset, Math.min(rowRight - menu.width, window.innerWidth - menu.width - inset))
+    const top = anchor.bottom + menu.height + inset <= window.innerHeight ?
+      anchor.bottom + inset : Math.max(inset, anchor.top - menu.height - inset)
+    this.panel.style.left = `${left}px`
+    this.panel.style.top = `${top}px`
+  },
+
+  closeMenu(returnFocus = false) {
+    if (this.panel) this.panel.style.display = "none"
+    this.trigger?.setAttribute("aria-expanded", "false")
+    this.isOpen = false
+    if (returnFocus) this.trigger?.focus({ preventScroll: true })
+  },
+
+  destroyed() {
+    this.el.removeEventListener("click", this.onClick)
+    this.el.removeEventListener("keydown", this.onKey)
+    document.removeEventListener("pointerdown", this.onOutside)
+    document.removeEventListener("scroll", this.onScroll, true)
+    window.removeEventListener("resize", this.onResize)
+  },
+}
diff --git a/docs/analytics_sessions.md b/docs/analytics_sessions.md
index 8724863..def67e4 100644
--- a/docs/analytics_sessions.md
+++ b/docs/analytics_sessions.md
@@ -93,7 +93,12 @@ mix analytics.sessions.backfill --materialize-inventory --materialize-session-re
 Source deletion, copying or restoration must invalidate affected prepared data
 with `Sessions.invalidate/1` under the caller's existing authorization, then
 rebuild it. Do not reuse a retired space identifier before invalidation succeeds.
-Normal event arrival needs no explicit invalidation.
+Invalidation atomically hides the published generations in PostgreSQL and records
+them for cleanup; it does not wait for ClickHouse deletion. New readers cannot
+select the old generations, while reads already in progress retain the reader
+grace period. The background processor rebuilds from current source events, and
+cleanup reclaims retired generations independently. Normal event arrival needs
+no explicit invalidation.
 
 ## Query semantics
 
diff --git a/docs/audio_description.md b/docs/audio_description.md
new file mode 100644
index 0000000..31f708d
--- /dev/null
+++ b/docs/audio_description.md
@@ -0,0 +1,163 @@
+# Audio description
+
+Audio description makes a video followable for blind and low-vision viewers: a
+voice describes what happens on screen. A space opts in under **Settings →
+Features → Audio description**. From then on, every new upload and reprocessing
+run of a video of at most 10 minutes gets one description in its detected
+spoken language (English when no language is known):
+
+- `audio_description_<lang>.mp3`: a full mix of the video's own audio with the
+  spoken descriptions. It is also an HLS alternate audio rendition, so players
+  can switch to it.
+- `descriptions_<lang>.vtt`: a WebVTT with `Kind: descriptions`, containing exactly
+  the spoken descriptions, timed to when they are spoken.
+
+Existing videos only get audio descriptions when they are processed again.
+
+The flow input can set `audio_description.fallback_language` (default `en`).
+A `fallback_language` step parameter overrides that default. These values are
+used only when the original language is unknown; hosts can snapshot a space's
+preferred fallback in the flow input without coupling the pipeline to space settings.
+
+## How descriptions are placed
+
+- **Original language.** The picture is described directly in the language
+  detected by transcription. If no language is known, English is used. No second
+  language or translation is generated by default.
+- **In the pauses, otherwise ducked.** Where speech is, is measured with
+  speech-to-text (the `ai.transcribe_audio` segments, or a transcription made for
+  this purpose), never guessed by the description model. A description that fits a
+  pause near its moment (up to 1 s earlier or 2 s later) plays there and leaves the
+  original audio untouched. When none fits, it plays at its moment and the original
+  audio fades to 20% underneath it (0.3 s fades). Descriptions are not shortened to
+  make room.
+- **In sync with the picture.** Cuts are detected with FFmpeg `scdet` and grouped
+  into scenes of at least 3 s, so a fast montage is still described. A description
+  starts while its scene is on screen and at least half of it is spoken during the
+  scene; a pause after the cut never counts as room for it. One that can no longer
+  start in its scene, because earlier descriptions ran long, is left out.
+- **Labelled stills.** The image model gets one 360p still per ~3 s per shot
+  (at least one per cut), labelled `S<scene> at <time>`, in batches of 12, with the
+  scenes, speech and numbered pauses (each with a word budget) as context.
+
+## Flow steps
+
+The publishing presets (`publish_default`, `publish_local`, `publish_remote`,
+`publish_remote_local`) contain these optional background steps. Each one skips
+itself (`status: "skipped"`, `reason: "not_requested"`) unless the run input has
+`audio_description`, so disabled spaces do not call the AI providers. Nothing in the publish
+path waits for them; when a mix step finishes, Core stores the result, rebuilds the
+HLS master playlist and republishes `manifest.json`.
+
+| Step | Type | Runs on | Does |
+| --- | --- | --- | --- |
+| `detect_scenes` | `media.detect_scenes` | FLAME (media pool) | Cuts, scenes and stills in one decode of the canonical source |
+| `describe_video` | `ai.describe_video` | inline | Original-language cues |
+| `speak_descriptions_original` | `ai.speak_descriptions` | inline | Text-to-speech per cue; existing clips are reused on retry |
+| `mix_audio_description_original` | `media.mix_audio_description` | FLAME (media pool) | Timeline, ducked mix, VTT and the HLS audio rendition |
+
+Run input:
+
+```json
+{"audio_description": {"languages": ["original"], "fallback_language": "en"}}
+```
+
+Uploads and the public `input_url` API add this when the space has the feature on
+and the host allows it at that moment (see below). Existing runs keep their
+original versioned flow definition; newly started runs use the single-language preset.
+Videos longer than `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` (default `600`) are
+skipped with `reason: "video_too_long"`, `video_duration_seconds` and
+`max_duration_seconds`; videos without a video stream with `no_video`.
+
+Transient provider and storage errors (timeouts, 408/429/5xx) are retried with the
+flow engine's retry budget. Other failures make the step `unavailable`; they never
+block publication. Working objects (stills, cues, speech clips) are private and
+live under `<embed>/vN/audio_description/`.
+
+## Outputs
+
+Files sit next to the other media of the video version (`<embed>/vN/`):
+`audio_description_<lang>.mp3`, `audio_description_<lang>_hls/playlist.m3u8` and
+`descriptions_<lang>.vtt`. Generated rows are identified by video version and
+generation language; uploaded tracks may share the same language.
+
+The HLS master playlist lists each MP3 in the `audio` group:
+
+```text
+#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Dutch (audio description)",LANGUAGE="nl",DEFAULT=NO,AUTOSELECT=YES,CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",URI="audio_description_nl_hls/playlist.m3u8"
+```
+
+`manifest.json` has a separate key, so players that don't know it are unaffected
+(the existing `audio_tracks` and `subtitles` don't include audio descriptions):
+
+```json
+"audio_descriptions": [
+  {
+    "language": "nl",
+    "label": "Dutch (audio description)",
+    "audio": {"path": "https://…/audio_description_nl.mp3", "hls_playlist": "audio_description_nl_hls/playlist.m3u8", "file_size": 123456},
+    "vtt": {"path": "https://…/descriptions_nl.vtt", "file_size": 1234}
+  }
+]
+```
+
+The key is omitted when a video has none. The detailed video API payload has the
+same `audio_descriptions` list. The dashboard video page lists the available
+languages and HLS/MP3/VTT formats under **Audio descriptions** in Settings and
+**Audio** in Info, where descriptions are marked `(AD)`.
+
+The file menu on audio tracks, audio descriptions and subtitles provides file
+downloads and replacement. Removing a track asks for confirmation.
+
+Under **Settings → Audio descriptions**, tracks can be uploaded, renamed,
+retagged with a language, replaced, or removed. Upload a complete MP3 mix with
+both the original audio and spoken descriptions; the player switches tracks
+rather than mixing them. Uploaded tracks can share a language. A manually
+replaced track has no generated VTT, since the old text may not match the new
+audio. The replacement menu also supports uploading or replacing the associated
+VTT. The generated pipeline creates both files automatically. Background publication preserves manually edited and removed tracks.
+
+## Who may use it
+
+`MaveCore.UsageLimits.can_use_audio_description?/1` is an optional host callback.
+Without a host policy every space may turn the feature on. A host can refuse with
+`{:error, reason}` and provide `restriction_copy(:audio_description, reason)`;
+the dashboard then shows the notice and keeps the toggle off. Turning the feature
+off is always allowed. The check is repeated for every new run, so a space that
+loses access stops getting audio descriptions without changing its setting.
+
+## Providers and configuration
+
+The default providers are Scaleway Generative APIs and Mistral. Video stills,
+speech timings and description text are sent to the configured providers.
+
+| Variable | Default | Purpose |
+| --- | --- | --- |
+| `SCALEWAY_API_KEY` | — | Scaleway IAM application with only `GenerativeApisModelAccess` |
+| `MISTRAL_API_KEY` | — | Already used for transcription; also used for text-to-speech |
+| `MAVE_AUDIO_DESCRIPTION_ENDPOINT` | `https://api.scaleway.ai/v1/chat/completions` | Override with `https://api.scaleway.ai/<project-id>/v1/chat/completions` for a project-scoped key |
+| `MAVE_AUDIO_DESCRIPTION_MODEL` | `gemma-4-26b-a4b-it` | Describe and translate model |
+| `MAVE_AUDIO_DESCRIPTION_REASONING_EFFORT` | `none` | Scaleway `reasoning_effort`; with reasoning, Gemma runs out of tokens |
+| `MAVE_AUDIO_DESCRIPTION_TTS_MODEL` | `voxtral-mini-tts-3-0` | Mistral text-to-speech model |
+| `MAVE_AUDIO_DESCRIPTION_VOICES` | `en:gb_jane_neutral,nl:voice_3145` | Voice per language |
+| `MAVE_AUDIO_DESCRIPTION_VOICE` | `gb_jane_neutral` | Voice for languages without one |
+| `MAVE_AUDIO_DESCRIPTION_MAX_SECONDS` | `600` | Longest video that gets descriptions |
+
+The default voices are Jane (English) and Lotte (Dutch), both presets. Lotte
+requires Voxtral 3; the older `voxtral-mini-tts-2603` model rejects this voice.
+When overriding the model or voices, verify that they are compatible. See
+[Mistral's voice catalog](https://docs.mistral.ai/studio/audio/text-to-speech/voices).
+
+Scope the Scaleway application's `GenerativeApisModelAccess` policy to the
+intended project and use that project's endpoint above. Setting a key's default
+project alone does not restrict its permissions. Prefer expiring credentials
+and keep them in the runtime environment, outside version control.
+
+Tests replace the providers through application config:
+
+```elixir
+config :mave_core, :audio_description,
+  chat_provider: MyChatStub,     # chat_json(system, content, opts)
+  speech_provider: MySpeechStub, # speak(text, language) -> {:ok, wav_bytes}
+  max_seconds: 600
+```
diff --git a/docs/flow_engine.md b/docs/flow_engine.md
index f6a6bca..8d1b773 100644
--- a/docs/flow_engine.md
+++ b/docs/flow_engine.md
@@ -117,6 +117,14 @@ New runs select the current built-in preset version. Existing runs and pinned
 custom versions do not gain steps automatically; reprocess with an updated flow
 when peaks are needed for older media.
 
+## Audio description
+
+The publishing presets include optional background steps that generate an audio
+description (a full-mix MP3 and a descriptions VTT, in English and Dutch) for
+spaces that opted in. They skip themselves unless the run input has
+`audio_description`, and nothing in the publish path waits for them. See
+[audio description](audio_description.md).
+
 ## Execution and recovery
 
 By default:
diff --git a/lib/mave_core/analytics/sessions.ex b/lib/mave_core/analytics/sessions.ex
index e78ecfb..38ea35a 100644
--- a/lib/mave_core/analytics/sessions.ex
+++ b/lib/mave_core/analytics/sessions.ex
@@ -565,7 +565,7 @@ defmodule MaveCore.Analytics.Sessions do
     :ok
   end
 
-  @doc "Hide retired analytics immediately; obsolete generations are collected separately."
+  @doc "Hide prepared analytics immediately; physical cleanup runs after the reader grace period."
   def invalidate(space_hash) do
     with :ok <- validate_hash(space_hash), do: invalidate_transaction(space_hash)
   end
@@ -579,43 +579,22 @@ defmodule MaveCore.Analytics.Sessions do
 
   defp invalidate_locked(space) do
     lock!(space)
-    Repo.query!("DELETE FROM analytics_session_buckets WHERE space_hash = $1", [space])
 
-    with {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_sessions DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_session_years DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_session_reports DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_overview_days DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ),
-         {:ok, _} <-
-           ch(
-             "ALTER TABLE analytics_overview_views DELETE WHERE space_hash = {$0:String} SETTINGS mutations_sync = 1",
-             [space],
-             60_000
-           ) do
-      Repo.query!("DELETE FROM analytics_session_retirements WHERE space_hash = $1", [space])
-      :ok
-    else
-      _ -> {:error, :analytics_unavailable}
-    end
+    # Unpublish and retain a durable cleanup record in one transaction. Readers
+    # already using a generation keep it for the grace period; new readers cannot
+    # select it. A ClickHouse outage must not block this visibility change.
+    Repo.query!(
+      """
+      INSERT INTO analytics_session_retirements (space_hash, generation, retired_at)
+      SELECT space_hash, generation, now() FROM analytics_session_buckets
+      WHERE space_hash = $1
+      ON CONFLICT (space_hash, generation) DO NOTHING
+      """,
+      [space]
+    )
+
+    Repo.query!("DELETE FROM analytics_session_buckets WHERE space_hash = $1", [space])
+    :ok
   end
 
   @doc "Delete retired generations after the reader grace period, in batches per space."
diff --git a/lib/mave_core/assets.ex b/lib/mave_core/assets.ex
index 18f9843..fa0bd9b 100644
--- a/lib/mave_core/assets.ex
+++ b/lib/mave_core/assets.ex
@@ -5,7 +5,7 @@ defmodule MaveCore.Assets do
 
   import Ecto.Query, warn: false
 
-  alias MaveCore.Assets.{AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{AudioDescription, AudioTrack, Subtitle, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, ManifestPublisher, SettingsSerializer}
   alias MaveCore.EncodingBooster
@@ -13,6 +13,7 @@ defmodule MaveCore.Assets do
   alias MaveCore.Flow.Steps.{
     MediaBuildHlsMasterStep,
     MediaExtractFrameStep,
+    MediaMixAudioDescriptionStep,
     MediaPackageHlsAudioStep
   }
 
@@ -172,6 +173,148 @@ defmodule MaveCore.Assets do
     Repo.delete(track)
   end
 
+  def get_audio_description_for_embed(id, %Embed{} = embed) when is_binary(id) do
+    embed = Repo.preload(embed, :asset)
+    video_id = embed.asset && embed.asset.current_video_id
+
+    if is_binary(video_id) do
+      AudioDescription
+      |> where([description], is_nil(description.deleted_at))
+      |> Repo.get_by(id: id, video_id: video_id)
+    end
+  end
+
+  def get_audio_description_for_embed(_, _), do: nil
+
+  def update_audio_description_outputs(%Embed{} = embed, id, attrs) do
+    case get_audio_description_for_embed(id, embed) do
+      nil ->
+        {:error, :audio_description_not_found}
+
+      description ->
+        attrs = Map.take(attrs, [:label, :language]) |> Map.put(:user_managed, true)
+
+        with {:ok, updated} <- description |> AudioDescription.changeset(attrs) |> Repo.update(),
+             :ok <- refresh_audio_outputs(embed) do
+          {:ok, updated}
+        end
+    end
+  end
+
+  def delete_audio_description_outputs(%Embed{} = embed, id) do
+    case get_audio_description_for_embed(id, embed) do
+      nil ->
+        {:error, :audio_description_not_found}
+
+      description ->
+        with {:ok, deleted} <-
+               description
+               |> AudioDescription.changeset(%{
+                 deleted_at: DateTime.utc_now(),
+                 user_managed: true
+               })
+               |> Repo.update(),
+             :ok <- refresh_audio_outputs(embed) do
+          {:ok, deleted}
+        end
+    end
+  end
+
+  def ingest_uploaded_audio_description(%Embed{} = embed, attrs, source_bucket, source_key) do
+    embed = Repo.preload(embed, [:space, asset: [:current_video]])
+    id = Map.get(attrs, "audio_track_id")
+
+    target =
+      if id in [nil, ""],
+        do: %AudioDescription{},
+        else: get_audio_description_for_embed(id, embed)
+
+    with %Video{} = video <- embed.asset && embed.asset.current_video,
+         %AudioDescription{} = description <- target,
+         {:ok, original_name} <- require_binary(attrs["filename"], :filename),
+         filename =
+           "audio_description_upload_#{Ecto.UUID.generate()}_#{Path.rootname(Path.basename(original_name))}.mp3",
+         region = embed.space.region || "default",
+         changeset =
+           AudioDescription.changeset(description, %{
+             video_id: video.id,
+             language: attrs["language"],
+             label: blank_to_nil(attrs["label"]),
+             audio_filename: filename,
+             audio_file_size: attrs["file_size"],
+             vtt_filename: nil,
+             vtt_file_size: nil,
+             cue_count: nil,
+             ducked_cue_count: nil,
+             user_managed: true
+           }),
+         {:ok, candidate} <- Ecto.Changeset.apply_action(changeset, :insert),
+         {:ok, copied} <-
+           copy_audio_source(
+             embed,
+             filename,
+             source_bucket,
+             source_key,
+             attrs,
+             region,
+             upload_source_storage_profile()
+           ),
+         {:ok, %{"status" => "ok"}} <-
+           package_audio_track(
+             embed,
+             %AudioTrack{
+               id: candidate.id || Ecto.UUID.generate(),
+               label: AudioDescription.display_label(candidate),
+               language: candidate.language,
+               default: false,
+               filename: filename,
+               codec: "mp3"
+             },
+             copied,
+             region
+           ),
+         {:ok, saved} <- Repo.insert_or_update(changeset),
+         :ok <- refresh_audio_outputs(embed) do
+      {:ok, saved}
+    else
+      nil -> {:error, :audio_description_not_found}
+      {:error, _} = error -> error
+      {:ok, output} -> {:error, {:audio_description_packaging_failed, output["status"]}}
+    end
+  end
+
+  def ingest_uploaded_audio_description_vtt(%Embed{} = embed, attrs, source_bucket, source_key) do
+    embed = Repo.preload(embed, [:space, asset: [:current_video]])
+    storage = storage_adapter()
+    region = embed.space.region || "default"
+    filename = "descriptions_upload_#{Ecto.UUID.generate()}.vtt"
+    key = audio_source_key(embed.hash, Embeds.current_video_version(embed), filename)
+    bucket = Storage.bucket_for_space(embed.space.hash, region)
+
+    with %AudioDescription{} = description <-
+           get_audio_description_for_embed(attrs["subtitle_id"], embed),
+         {:ok, body} <- storage.get(source_bucket, source_key, upload_source_storage_profile()),
+         true <-
+           is_binary(body) and String.valid?(body) and
+             String.starts_with?(String.trim_leading(body, "\uFEFF"), "WEBVTT"),
+         {:ok, _} <- storage.put_public(bucket, key, body, "text/vtt", region),
+         {:ok, saved} <-
+           description
+           |> AudioDescription.changeset(%{
+             vtt_filename: filename,
+             vtt_file_size: byte_size(body),
+             user_managed: true
+           })
+           |> Repo.update(),
+         :ok <- refresh_audio_outputs(embed) do
+      {:ok, saved}
+    else
+      nil -> {:error, :audio_description_not_found}
+      false -> {:error, :invalid_vtt}
+      {:error, _} = error -> error
+    end
+  end
+
   def ingest_uploaded_thumbnail(%Embed{} = embed, source_bucket, source_key, attrs \\ %{})
       when is_binary(source_bucket) and is_binary(source_key) and is_map(attrs) do
     embed = Repo.preload(embed, [:space, :settings, asset: [:current_video]])
@@ -1036,6 +1179,12 @@ defmodule MaveCore.Assets do
               "status" => "ok",
               "audio_tracks" => audio_tracks
             }},
+           {"hls_audio_descriptions",
+            %{
+              "step_type" => "media.mix_audio_description",
+              "status" => "ok",
+              "audio_tracks" => hls_audio_descriptions(embed)
+            }},
            {"hls_subtitles",
             %{
               "step_type" => "subtitle.collect",
@@ -1223,6 +1372,33 @@ defmodule MaveCore.Assets do
     end)
   end
 
+  defp hls_audio_descriptions(%Embed{} = embed) do
+    embed.asset.current_video.id
+    |> list_audio_descriptions()
+    |> Enum.map(fn description ->
+      %{
+        "id" => "audio_description_#{description.id}",
+        "label" => AudioDescription.display_label(description),
+        "language" => description.language,
+        "default" => false,
+        "hls_playlist" => AudioDescription.hls_playlist(description),
+        "hls_bandwidth" => @audio_hls_bandwidth,
+        "hls_channels" => @audio_hls_channels,
+        "characteristics" => MediaMixAudioDescriptionStep.characteristics()
+      }
+    end)
+  end
+
+  @doc "Audio descriptions of a video version, by language."
+  def list_audio_descriptions(video_id) when is_binary(video_id) do
+    AudioDescription
+    |> where([description], description.video_id == ^video_id and is_nil(description.deleted_at))
+    |> order_by([description], asc: description.language)
+    |> Repo.all()
+  end
+
+  def list_audio_descriptions(_video_id), do: []
+
   defp hls_subtitles(%Embed{} = embed) do
     version = Embeds.current_video_version(embed)
 
diff --git a/lib/mave_core/assets/audio_description.ex b/lib/mave_core/assets/audio_description.ex
new file mode 100644
index 0000000..4a757d0
--- /dev/null
+++ b/lib/mave_core/assets/audio_description.ex
@@ -0,0 +1,65 @@
+defmodule MaveCore.Assets.AudioDescription do
+  @moduledoc """
+  A generated audio-description track of a video in one language: a full-mix MP3
+  (the video's audio with spoken descriptions) and the matching descriptions VTT.
+  """
+  use MaveCore.Schema
+  import Ecto.Changeset
+
+  alias MaveCore.Assets.Video
+
+  schema "audio_descriptions" do
+    field :language, :string
+    field :label, :string
+    field :generation_language, :string
+    field :user_managed, :boolean, default: false
+    field :deleted_at, :utc_datetime_usec
+    field :audio_filename, :string
+    field :audio_file_size, :integer
+    field :vtt_filename, :string
+    field :vtt_file_size, :integer
+    field :cue_count, :integer
+    field :ducked_cue_count, :integer
+
+    belongs_to :video, Video
+
+    timestamps()
+  end
+
+  def changeset(audio_description, attrs) do
+    audio_description
+    |> cast(attrs, [
+      :video_id,
+      :language,
+      :label,
+      :generation_language,
+      :user_managed,
+      :deleted_at,
+      :audio_filename,
+      :audio_file_size,
+      :vtt_filename,
+      :vtt_file_size,
+      :cue_count,
+      :ducked_cue_count
+    ])
+    |> validate_required([:video_id, :language, :audio_filename])
+    |> validate_format(:language, ~r/^[a-z]{2,3}(?:-[A-Za-z0-9]{2,8})*$/)
+    |> foreign_key_constraint(:video_id)
+    |> unique_constraint([:video_id, :generation_language])
+  end
+
+  def display_label(%__MODULE__{} = description) do
+    name =
+      description.label || MaveCore.Languages.spoken_language(description.language) ||
+        String.upcase(description.language)
+
+    "#{name} (audio description)"
+  end
+
+  @doc "HLS playlist of the audio track, relative to the video version's prefix."
+  def hls_playlist(%__MODULE__{audio_filename: filename}), do: hls_playlist(filename)
+
+  def hls_playlist(filename) when is_binary(filename) do
+    (filename |> Path.basename() |> Path.rootname()) <> "_hls/playlist.m3u8"
+  end
+end
diff --git a/lib/mave_core/assets/video.ex b/lib/mave_core/assets/video.ex
index a452159..d988c1c 100644
--- a/lib/mave_core/assets/video.ex
+++ b/lib/mave_core/assets/video.ex
@@ -3,7 +3,7 @@ defmodule MaveCore.Assets.Video do
   use MaveCore.Schema
   import Ecto.Changeset
 
-  alias MaveCore.Assets.{Asset, AudioTrack, Rendition, Subtitle}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle}
 
   schema "videos" do
     field :status, :string
@@ -19,6 +19,7 @@ defmodule MaveCore.Assets.Video do
     field :language, :string
 
     belongs_to :asset, Asset
+    has_many :audio_descriptions, AudioDescription
     has_many :audio_tracks, AudioTrack
     has_many :renditions, Rendition
     has_many :subtitles, Subtitle
diff --git a/lib/mave_core/audio_description.ex b/lib/mave_core/audio_description.ex
new file mode 100644
index 0000000..669f0c0
--- /dev/null
+++ b/lib/mave_core/audio_description.ex
@@ -0,0 +1,107 @@
+defmodule MaveCore.AudioDescription do
+  @moduledoc """
+  Audio description: per video, a full-mix MP3 (the video's audio with spoken
+  descriptions of what is on screen) and a descriptions VTT in the original language.
+
+  New runs describe the picture directly in the detected language, falling back
+  to English when no language is known. See `docs/audio_description.md`.
+  """
+
+  alias MaveCore.Spaces
+  alias MaveCore.Spaces.Space
+
+  @source_language "en"
+  @languages ["en", "nl"]
+  @default_max_seconds 600
+
+  def source_language, do: @source_language
+  def languages, do: @languages
+
+  @doc """
+  The `audio_description` run input for a new flow run in `space`, or `nil` when
+  the space doesn't get audio descriptions.
+  """
+  def run_input(%Space{} = space) do
+    if Spaces.audio_description_active?(space),
+      do: %{"languages" => ["original"], "fallback_language" => "en"},
+      else: nil
+  end
+
+  def run_input(_space), do: nil
+
+  @doc "Languages requested by a run, or `[]` when it has no audio description."
+  def requested_languages(%{"audio_description" => %{"languages" => languages}})
+      when is_list(languages) do
+    languages = Enum.filter(languages, &is_binary/1)
+
+    cond do
+      languages == [] -> []
+      "original" in languages -> ["original"]
+      true -> Enum.uniq([@source_language | languages])
+    end
+  end
+
+  def requested_languages(_run_input), do: []
+
+  @doc "Original language from transcription or run metadata, with a configurable fallback."
+  def original_language(run_input, outputs, fallback_language \\ nil) do
+    candidates = [
+      get_in(outputs, ["transcribe_audio", "transcription_language"]),
+      get_in(outputs, ["transcribe_audio", "language"]),
+      run_input["language"]
+    ]
+
+    fallback =
+      normalize_language(fallback_language) ||
+        normalize_language(get_in(run_input, ["audio_description", "fallback_language"])) ||
+        @source_language
+
+    Enum.find_value(candidates, fallback, &normalize_language/1)
+  end
+
+  defp normalize_language(value) when is_binary(value) do
+    value = value |> String.trim() |> String.downcase() |> String.split(~r/[-_]/) |> hd()
+    if value =~ ~r/^[a-z]{2,3}$/ and value not in ["und", "zxx"], do: value
+  end
+
+  defp normalize_language(_), do: nil
+
+  def requested?(run_input), do: requested_languages(run_input) != []
+
+  @doc "Longest video that gets an audio description, in seconds."
+  def max_seconds do
+    case config(:max_seconds, System.get_env("MAVE_AUDIO_DESCRIPTION_MAX_SECONDS")) do
+      value when is_integer(value) and value > 0 ->
+        value
+
+      value when is_binary(value) ->
+        case Integer.parse(value) do
+          {seconds, ""} when seconds > 0 -> seconds
+          _ -> @default_max_seconds
+        end
+
+      _ ->
+        @default_max_seconds
+    end
+  end
+
+  @doc "Object key prefix of a video version (`<embed>/vN` or `<embed>`)."
+  def version_prefix(embed_hash, version) when is_integer(version) and version > 0,
+    do: "#{embed_hash}/v#{version}"
+
+  def version_prefix(embed_hash, _version), do: embed_hash
+
+  @doc "Private working objects (stills, cues, speech clips) of a video version."
+  def work_prefix(embed_hash, version),
+    do: "#{version_prefix(embed_hash, version)}/audio_description"
+
+  def audio_filename(language), do: "audio_description_#{language}.mp3"
+  def vtt_filename(language), do: "descriptions_#{language}.vtt"
+
+  @doc false
+  def config(key, default \\ nil) do
+    :mave_core
+    |> Application.get_env(:audio_description, [])
+    |> Keyword.get(key, default)
+  end
+end
diff --git a/lib/mave_core/audio_description/cues.ex b/lib/mave_core/audio_description/cues.ex
new file mode 100644
index 0000000..cf79e32
--- /dev/null
+++ b/lib/mave_core/audio_description/cues.ex
@@ -0,0 +1,177 @@
+defmodule MaveCore.AudioDescription.Cues do
+  @moduledoc """
+  Description cues: parsing model output, cleaning it up and writing the
+  descriptions WebVTT (`Kind: descriptions`).
+
+  A cue is `%{start: seconds, end: seconds, text: String.t()}`, optionally with
+  `scene: %{start, end}` (the scene it is tied to).
+  """
+
+  alias MaveCore.AudioDescription.Timeline
+
+  @min_cue_seconds 0.5
+
+  @doc """
+  Parse a timestamp into seconds. Accepts numbers and strings like `HH:MM:SS.mmm`,
+  `MM:SS`, `MM:SS.mmm` or `SS.mmm` (comma decimals allowed).
+  """
+  def parse_timestamp(value) when is_number(value) and value >= 0, do: value * 1.0
+
+  def parse_timestamp(value) when is_binary(value) do
+    value = value |> String.trim() |> String.replace(",", ".", global: false)
+
+    if Regex.match?(~r/^\d+(:\d+){0,2}(\.\d+)?$/, value) do
+      value
+      |> String.split(":")
+      |> Enum.reduce(0.0, fn part, acc -> acc * 60 + parse_number(part) end)
+    end
+  end
+
+  def parse_timestamp(_value), do: nil
+
+  defp parse_number(part) do
+    {number, ""} = Float.parse(part)
+    number
+  end
+
+  @doc "WebVTT timestamp `HH:MM:SS.mmm`."
+  def format_timestamp(seconds) do
+    total_ms = max(0, round(seconds * 1000))
+    ms = rem(total_ms, 1000)
+    total_s = div(total_ms, 1000)
+
+    :io_lib.format("~2..0B:~2..0B:~2..0B.~3..0B", [
+      div(total_s, 3600),
+      rem(div(total_s, 60), 60),
+      rem(total_s, 60),
+      ms
+    ])
+    |> IO.iodata_to_binary()
+  end
+
+  @doc "Rough time needed to speak a text aloud, in seconds."
+  def estimate_speech_seconds(text) do
+    words = text |> String.split(~r/\s+/, trim: true) |> length()
+    max(1.0, words / 2.5)
+  end
+
+  @doc """
+  Clean up cues: drop invalid ones, sort, merge cues that start at the same
+  moment, repair end times, remove overlaps and clamp to the video duration.
+  """
+  def normalize(cues, duration \\ nil) do
+    limit = if is_number(duration) and duration > 0, do: duration * 1.0
+
+    cues
+    |> Enum.flat_map(&parse_cue(&1, limit))
+    |> Enum.sort_by(&{&1.start, &1.end})
+    |> Enum.reduce([], fn cue, acc ->
+      case acc do
+        [prev | rest] when cue.start - prev.start < 0.05 ->
+          [%{prev | text: prev.text <> " " <> cue.text, end: max(prev.end, cue.end)} | rest]
+
+        _ ->
+          [cue | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> fix_ends(limit)
+    |> Enum.filter(&(&1.end > &1.start))
+  end
+
+  defp parse_cue(cue, limit) do
+    text = cue |> field(:text) |> clean_text()
+    start = cue |> field(:start) |> parse_timestamp()
+
+    if text == "" or is_nil(start) or (limit && start >= limit) do
+      []
+    else
+      stop = cue |> field(:end) |> parse_timestamp()
+
+      stop =
+        if is_nil(stop) or stop <= start, do: start + estimate_speech_seconds(text), else: stop
+
+      [%{start: start, end: stop, text: text} |> maybe_put_scene(field(cue, :scene))]
+    end
+  end
+
+  defp fix_ends(cues, limit) do
+    next_starts = cues |> Enum.drop(1) |> Enum.map(& &1.start) |> Kernel.++([nil])
+
+    cues
+    |> Enum.zip(next_starts)
+    |> Enum.map(fn {cue, next_start} ->
+      stop = if next_start && cue.end > next_start, do: next_start, else: cue.end
+      stop = if limit && stop > limit, do: limit, else: stop
+      stop = min_length_end(cue.start, stop, next_start || limit)
+
+      %{cue | start: Timeline.round3(cue.start), end: Timeline.round3(stop)}
+    end)
+  end
+
+  # Short cues are stretched to the minimum length, but never past the next cue or the end.
+  defp min_length_end(start, stop, _ceiling) when stop - start >= @min_cue_seconds, do: stop
+  defp min_length_end(start, _stop, nil), do: start + @min_cue_seconds
+  defp min_length_end(start, _stop, ceiling), do: min(start + @min_cue_seconds, ceiling)
+
+  defp maybe_put_scene(cue, %{start: start, end: stop}) when is_number(start) and is_number(stop),
+    do: Map.put(cue, :scene, %{start: start, end: stop})
+
+  defp maybe_put_scene(cue, %{"start" => start, "end" => stop}),
+    do: maybe_put_scene(cue, %{start: start, end: stop})
+
+  defp maybe_put_scene(cue, _scene), do: cue
+
+  defp clean_text(text) when is_binary(text),
+    do: text |> String.replace(~r/\s+/u, " ") |> String.trim()
+
+  defp clean_text(_text), do: ""
+
+  defp field(map, key) when is_map(map), do: Map.get(map, key, Map.get(map, Atom.to_string(key)))
+
+  @doc "The descriptions WebVTT for `cues` in `language`."
+  def to_vtt(cues, language) do
+    body =
+      cues
+      |> Enum.with_index(1)
+      |> Enum.map(fn {cue, i} ->
+        "#{i}\n#{format_timestamp(cue.start)} --> #{format_timestamp(cue.end)}\n#{escape(cue.text)}\n"
+      end)
+
+    Enum.join(["WEBVTT\nKind: descriptions\nLanguage: #{language}\n" | body], "\n")
+  end
+
+  defp escape(text) do
+    text
+    |> String.replace("&", "&amp;")
+    |> String.replace("<", "&lt;")
+    |> String.replace(">", "&gt;")
+  end
+
+  @doc "Cues as JSON-safe maps (string keys) for storage."
+  def to_json(cues) do
+    Enum.map(cues, fn cue ->
+      %{"start" => cue.start, "end" => cue.end, "text" => cue.text}
+      |> put_scene_json(cue[:scene])
+    end)
+  end
+
+  defp put_scene_json(map, %{start: start, end: stop}),
+    do: Map.put(map, "scene", %{"start" => start, "end" => stop})
+
+  defp put_scene_json(map, _scene), do: map
+
+  @doc "Cues read back from `to_json/1`."
+  def from_json(list) when is_list(list) do
+    Enum.flat_map(list, fn
+      %{"start" => start, "end" => stop, "text" => text} = cue
+      when is_number(start) and is_number(stop) and is_binary(text) ->
+        [%{start: start * 1.0, end: stop * 1.0, text: text} |> maybe_put_scene(cue["scene"])]
+
+      _ ->
+        []
+    end)
+  end
+
+  def from_json(_), do: []
+end
diff --git a/lib/mave_core/audio_description/mistral_speech.ex b/lib/mave_core/audio_description/mistral_speech.ex
new file mode 100644
index 0000000..872c889
--- /dev/null
+++ b/lib/mave_core/audio_description/mistral_speech.ex
@@ -0,0 +1,95 @@
+defmodule MaveCore.AudioDescription.MistralSpeech do
+  @moduledoc """
+  Text-to-speech with Voxtral on the Mistral API.
+
+  Every language gets a voice in that language, because Voxtral keeps the accent
+  of its voice prompt. Voices come from `MAVE_AUDIO_DESCRIPTION_VOICES`
+  (`en:gb_jane_neutral,nl:voice_3145` by default); a language without one
+  falls back to `MAVE_AUDIO_DESCRIPTION_VOICE`. Never clone voices from customer
+  videos.
+  """
+
+  @endpoint "https://api.mistral.ai/v1/audio/speech"
+  @default_model "voxtral-mini-tts-3-0"
+  @default_voices "en:gb_jane_neutral,nl:voice_3145"
+  @default_voice "gb_jane_neutral"
+  @pool_timeout_ms 30_000
+  @receive_timeout_ms 2 * 60 * 1000
+
+  @doc "Speaks `text` in `language` and returns WAV bytes."
+  def speak(text, language) when is_binary(text) and is_binary(language) do
+    with {:ok, api_key} <- fetch_api_key() do
+      body = %{
+        "model" => env("MAVE_AUDIO_DESCRIPTION_TTS_MODEL", @default_model),
+        "input" => text,
+        "voice_id" => voice(language),
+        "response_format" => "wav"
+      }
+
+      case Req.post(@endpoint,
+             json: body,
+             headers: [{"authorization", "Bearer #{api_key}"}, {"accept", "application/json"}],
+             finch: [pool_timeout: @pool_timeout_ms],
+             receive_timeout: @receive_timeout_ms,
+             retry: :transient,
+             max_retries: 3
+           ) do
+        {:ok, %{status: status, body: %{"audio_data" => audio}}}
+        when status in 200..299 and is_binary(audio) ->
+          decode_audio(audio)
+
+        {:ok, %{status: status}} when status in 200..299 ->
+          {:error, :empty_speech_audio}
+
+        {:ok, %{status: status, body: body}} ->
+          {:error, {:http_error, status, body |> inspect() |> String.slice(0, 600)}}
+
+        {:error, reason} ->
+          {:error, reason}
+      end
+    end
+  end
+
+  defp decode_audio(audio) do
+    case Base.decode64(audio, ignore: :whitespace) do
+      {:ok, bytes} -> {:ok, bytes}
+      :error -> {:error, :invalid_speech_audio}
+    end
+  end
+
+  @doc "The voice for `language`: its exact tag, then its base language, then the fallback."
+  def voice(language) do
+    voices = voices()
+    base = language |> String.split("-") |> hd()
+
+    Map.get(voices, language) || Map.get(voices, base) ||
+      env("MAVE_AUDIO_DESCRIPTION_VOICE", @default_voice)
+  end
+
+  defp voices do
+    "MAVE_AUDIO_DESCRIPTION_VOICES"
+    |> env(@default_voices)
+    |> String.split(",", trim: true)
+    |> Enum.flat_map(fn pair ->
+      case String.split(pair, ":", parts: 2) do
+        [lang, voice] when lang != "" and voice != "" -> [{String.trim(lang), String.trim(voice)}]
+        _ -> []
+      end
+    end)
+    |> Map.new()
+  end
+
+  defp fetch_api_key do
+    case System.get_env("MISTRAL_API_KEY") do
+      key when is_binary(key) and key != "" -> {:ok, key}
+      _ -> {:error, :mistral_api_key_missing}
+    end
+  end
+
+  defp env(name, default) do
+    case System.get_env(name) do
+      value when is_binary(value) and value != "" -> String.trim(value)
+      _ -> default
+    end
+  end
+end
diff --git a/lib/mave_core/audio_description/mix.ex b/lib/mave_core/audio_description/mix.ex
new file mode 100644
index 0000000..61503f7
--- /dev/null
+++ b/lib/mave_core/audio_description/mix.ex
@@ -0,0 +1,85 @@
+defmodule MaveCore.AudioDescription.Mix do
+  @moduledoc """
+  FFmpeg arguments that mix the video's own audio with the description track.
+
+  The original audio fades to `duck_volume` (20%) under every description that
+  plays over speech, with `fade` (0.3 s) ramps; descriptions in pauses leave it
+  untouched. The result is a 48 kHz stereo MP3 as long as the original audio.
+  """
+
+  alias MaveCore.AudioDescription.Wav
+
+  @duck_volume 0.2
+  @fade_seconds 0.3
+  @kbps 128
+  @normalize "aresample=48000,aformat=sample_fmts=fltp:channel_layouts=stereo"
+
+  def duck_volume, do: @duck_volume
+  def fade_seconds, do: @fade_seconds
+
+  @doc "Gain expression for ffmpeg's `volume` filter: 1, fading to `duck_volume` in each interval."
+  def duck_expression(ducks, duck_volume \\ @duck_volume, fade \\ @fade_seconds)
+  def duck_expression([], _duck_volume, _fade), do: "1"
+
+  def duck_expression(ducks, duck_volume, fade) do
+    f = fixed(max(fade, 0.01))
+
+    # Trapezoid per interval: 0 before start-fade, 1 from start to end, 0 after end+fade.
+    ramps =
+      Enum.map(ducks, fn %{start: start, end: stop} ->
+        "clip(min((t-#{fixed(start - max(fade, 0.01))})/#{f},(#{fixed(stop + max(fade, 0.01))}-t)/#{f}),0,1)"
+      end)
+
+    max = Enum.reduce(tl(ramps), hd(ramps), fn ramp, acc -> "max(#{acc},#{ramp})" end)
+    "1-#{fixed(1 - duck_volume)}*#{max}"
+  end
+
+  @doc """
+  Arguments for the mix. `original` is the video's audio (`nil` when the video
+  has none), `description` the raw s16le mono description track.
+  """
+  def ffmpeg_args(original, description, output, ducks, duration) do
+    description_input = [
+      "-f",
+      "s16le",
+      "-ar",
+      Integer.to_string(Wav.sample_rate()),
+      "-ac",
+      "1",
+      "-i",
+      description
+    ]
+
+    {inputs, filter} =
+      if original do
+        {["-i", original | description_input],
+         "[0:a]#{@normalize},volume='#{duck_expression(ducks)}':eval=frame[orig];" <>
+           "[1:a]#{@normalize}[desc];" <>
+           "[orig][desc]amix=inputs=2:duration=first:normalize=0,alimiter=limit=0.97[out]"}
+      else
+        # No original audio: the descriptions alone, padded to the video length.
+        {description_input, "[0:a]#{@normalize}#{pad(duration)}[out]"}
+      end
+
+    ["-y", "-v", "error"] ++
+      inputs ++
+      [
+        "-filter_complex",
+        filter,
+        "-map",
+        "[out]",
+        "-c:a",
+        "libmp3lame",
+        "-b:a",
+        "#{@kbps}k",
+        output
+      ]
+  end
+
+  defp pad(duration) when is_number(duration) and duration > 0,
+    do: ",apad=whole_dur=#{fixed(duration)}"
+
+  defp pad(_duration), do: ""
+
+  defp fixed(value), do: :erlang.float_to_binary(value * 1.0, decimals: 3)
+end
diff --git a/lib/mave_core/audio_description/prompts.ex b/lib/mave_core/audio_description/prompts.ex
new file mode 100644
index 0000000..56ada3c
--- /dev/null
+++ b/lib/mave_core/audio_description/prompts.ex
@@ -0,0 +1,165 @@
+defmodule MaveCore.AudioDescription.Prompts do
+  @moduledoc """
+  Instructions and response schemas for the description and translation models.
+  """
+
+  alias MaveCore.Languages
+
+  @cues_schema %{
+    "type" => "object",
+    "properties" => %{
+      "duration_seconds" => %{"type" => "number"},
+      "cues" => %{
+        "type" => "array",
+        "items" => %{
+          "type" => "object",
+          "properties" => %{
+            "shot" => %{
+              "type" => "integer",
+              "description" => "Number of the scene this describes (S3 -> 3)"
+            },
+            "pause" => %{
+              "type" => "integer",
+              "description" =>
+                "Number of the pause it is placed in (P2 -> 2), or -1 during speech"
+            },
+            "max_words" => %{
+              "type" => "integer",
+              "description" => "Word limit for text: the pause's max words, or 6 during speech"
+            },
+            "start" => %{"type" => "string", "description" => "HH:MM:SS.mmm"},
+            "end" => %{"type" => "string", "description" => "HH:MM:SS.mmm"},
+            "text" => %{"type" => "string"}
+          },
+          "required" => ["shot", "pause", "max_words", "start", "end", "text"]
+        }
+      }
+    },
+    "required" => ["duration_seconds", "cues"]
+  }
+
+  @translations_schema %{
+    "type" => "object",
+    "properties" => %{"translations" => %{"type" => "array", "items" => %{"type" => "string"}}},
+    "required" => ["translations"]
+  }
+
+  def cues_schema, do: @cues_schema
+  def translations_schema, do: @translations_schema
+
+  @doc "The describer's instructions, followed by the timing context (`Timeline.timing_prompt/4`)."
+  def describe_instruction(duration, timing, language \\ "en") do
+    [
+      "You are a professional audio describer. You write the audio description track for a video,",
+      "so that blind and low-vision viewers can follow what happens on screen.",
+      "",
+      "Rules:",
+      "- Write every description in #{Languages.spoken_language(language) || language} (#{language}).",
+      "- Describe what is visible: actions, people (by appearance and role, use names only if shown on screen),",
+      "  setting, scene and location changes, facial expressions and on-screen text (read text out; keep brand names,",
+      "  logos and URLs exactly as written).",
+      "- Do not describe what can be heard (dialogue, narration, music) unless it is needed to understand the image.",
+      "- Present tense, objective, concise. No interpretation, no speculation, no 'we see' or 'the camera shows'.",
+      "",
+      "Sync with the picture (scenes come from cut detection, listed below):",
+      "- Every description is about one scene. Set `shot` to that scene's number (S3 -> 3). The description must",
+      "  start while that scene is on screen and be timed to the moment the thing it describes is visible.",
+      "  Never describe a scene after the video has cut away from it.",
+      "- A scene can contain several quick cuts. Then say in one description what the cuts show together, most",
+      "  important first (e.g. 'Terrace, garden pond, women with headphones.'), rather than only the first cut.",
+      "- Describe what is new or changed. Don't repeat what an earlier description already said; skip a moment",
+      "  when nothing new happens.",
+      "- At most one description per scene, plus one more for every further 6 seconds of a long scene. More",
+      "  descriptions don't fit between the speech and get dropped.",
+      "",
+      "Timing around the original speech (measured with speech recognition, listed below):",
+      "- Put descriptions inside a pause that overlaps their shot, so the original audio stays clear. Set `pause`",
+      "  to its number (P2 -> 2); the description must start and end inside that pause.",
+      "- First set `max_words`: the pause's 'max words', or at most 6 for a description during speech. Then",
+      "  write `text` with no more than `max_words` words. Short beats complete: 'Kitchen, dirty dishes.' is a",
+      "  good 3-word description. Never write two sentences for one cue.",
+      "- A long pause can hold several descriptions, each at the moment its event happens.",
+      "- Skip pauses with a budget under 2 words.",
+      "- When a shot has no usable pause but needs a description, place a short one during that shot's speech",
+      "  with `pause` = -1; the original audio is then lowered while it plays.",
+      "- Each cue lasts 1 to 8 seconds. Cues are chronological and never overlap each other.",
+      "- Timestamps are relative to the start of the video, formatted HH:MM:SS.mmm.",
+      duration_line(duration),
+      "- Also report the total video duration in seconds as duration_seconds.",
+      "",
+      timing
+    ]
+    |> Enum.reject(&(&1 == ""))
+    |> Enum.join("\n")
+  end
+
+  defp duration_line(duration) when is_number(duration) and duration > 0 do
+    "- The video is #{:erlang.float_to_binary(duration * 1.0, decimals: 3)} seconds long; no cue may end after that."
+  end
+
+  defp duration_line(_duration), do: ""
+
+  @doc "The closing text of a batch of labelled stills."
+  def stills_request(window, previous_texts) do
+    previous =
+      case previous_texts do
+        [] ->
+          nil
+
+        texts ->
+          "Already described just before this part (don't repeat):\n" <>
+            Enum.map_join(texts, "\n", &"- #{&1}")
+      end
+
+    [
+      "These are stills from #{seconds(window.start)}-#{seconds(window.end)} s of the video (at least one per camera",
+      "cut), labelled with their scene and time. Write the audio description cues for this part, in English.",
+      previous
+    ]
+    |> Enum.reject(&is_nil/1)
+    |> Enum.join("\n")
+  end
+
+  @doc "Translation instructions and the JSON input list for `cues`."
+  def translation_request(cues, language) do
+    name = "#{Languages.spoken_language(language) || language} (#{language})"
+
+    input =
+      cues
+      |> Enum.with_index()
+      |> Enum.map(fn {cue, i} ->
+        %{"i" => i, "seconds" => Float.round((cue.end - cue.start) * 1.0, 1), "text" => cue.text}
+      end)
+
+    instruction =
+      Enum.join(
+        [
+          "You translate an English audio description track for blind and low-vision viewers into #{name}.",
+          "Each item is spoken in a time slot of the video, so it must not run longer than its 'seconds'.",
+          "Rules:",
+          "- Translate every item; return exactly one translation per input item, in the same order, as `translations`.",
+          "- Keep the meaning, tone and present tense. Natural, idiomatic, concise spoken language.",
+          "- Each translation must be speakable within the item's 'seconds' at about 2.5 words per second;",
+          "  shorten the wording rather than exceed it.",
+          "- Keep brand names, logos and URLs exactly as written.",
+          "- Don't add information, notes, numbering or quotes."
+        ],
+        "\n"
+      )
+
+    {instruction, input}
+  end
+
+  @doc "Exactly one non-empty translation per cue, or an error."
+  def check_translations(results, count) when is_list(results) do
+    if length(results) == count and Enum.all?(results, &(is_binary(&1) and String.trim(&1) != "")) do
+      {:ok, Enum.map(results, &String.trim/1)}
+    else
+      {:error, {:translation_count_mismatch, length(results), count}}
+    end
+  end
+
+  def check_translations(_results, count), do: {:error, {:translation_count_mismatch, 0, count}}
+
+  defp seconds(value), do: :erlang.float_to_binary(value * 1.0, decimals: 2)
+end
diff --git a/lib/mave_core/audio_description/scaleway.ex b/lib/mave_core/audio_description/scaleway.ex
new file mode 100644
index 0000000..00bfb6b
--- /dev/null
+++ b/lib/mave_core/audio_description/scaleway.ex
@@ -0,0 +1,108 @@
+defmodule MaveCore.AudioDescription.Scaleway do
+  @moduledoc """
+  Chat completions with a JSON-schema answer on Scaleway Generative APIs (EU).
+
+  Describing uses an image model (Gemma 4) that gets labelled stills; it runs
+  with `reasoning_effort: "none"`, because with reasoning it runs out of tokens.
+  Requires `SCALEWAY_API_KEY` (an IAM application with only
+  `GenerativeApisModelAccess`).
+  """
+
+  @endpoint "https://api.scaleway.ai/v1/chat/completions"
+  @default_model "gemma-4-26b-a4b-it"
+  @pool_timeout_ms 30_000
+  @receive_timeout_ms 5 * 60 * 1000
+
+  @doc """
+  Sends `system` and the user `content` parts and decodes the JSON answer.
+
+  Options: `:schema` (required), `:max_tokens`, `:model`.
+  """
+  def chat_json(system, content, opts) when is_binary(system) and is_list(content) do
+    with {:ok, api_key} <- fetch_api_key() do
+      body =
+        %{
+          "model" => Keyword.get(opts, :model) || model(),
+          "max_tokens" => Keyword.get(opts, :max_tokens, 8_000),
+          "temperature" => 0.3,
+          "response_format" => %{
+            "type" => "json_schema",
+            "json_schema" => %{"name" => "result", "schema" => Keyword.fetch!(opts, :schema)}
+          },
+          "messages" => [
+            %{"role" => "system", "content" => system},
+            %{"role" => "user", "content" => content}
+          ]
+        }
+        |> maybe_put("reasoning_effort", reasoning_effort())
+
+      body
+      |> request(api_key)
+      |> decode_answer()
+    end
+  end
+
+  defp request(body, api_key) do
+    case Req.post(endpoint(),
+           json: body,
+           headers: [{"authorization", "Bearer #{api_key}"}, {"accept", "application/json"}],
+           finch: [pool_timeout: @pool_timeout_ms],
+           receive_timeout: @receive_timeout_ms,
+           retry: :transient,
+           max_retries: 3
+         ) do
+      {:ok, %{status: status, body: body}} when status in 200..299 -> {:ok, body}
+      {:ok, %{status: status, body: body}} -> {:error, {:http_error, status, truncate(body)}}
+      {:error, reason} -> {:error, reason}
+    end
+  end
+
+  defp decode_answer({:ok, %{"choices" => [%{"message" => %{"content" => content}} | _]}})
+       when is_binary(content) and content != "" do
+    content
+    |> String.trim()
+    |> String.replace(~r/^```(?:json)?\s*/i, "")
+    |> String.replace(~r/```\s*$/, "")
+    |> Jason.decode()
+    |> case do
+      {:ok, %{} = answer} -> {:ok, answer}
+      _ -> {:error, :invalid_model_json}
+    end
+  end
+
+  defp decode_answer({:ok, %{"choices" => [%{"finish_reason" => reason} | _]}}),
+    do: {:error, {:empty_model_answer, reason}}
+
+  defp decode_answer({:ok, _body}), do: {:error, :empty_model_answer}
+  defp decode_answer({:error, _reason} = error), do: error
+
+  defp fetch_api_key do
+    case System.get_env("SCALEWAY_API_KEY") do
+      key when is_binary(key) and key != "" -> {:ok, key}
+      _ -> {:error, :scaleway_api_key_missing}
+    end
+  end
+
+  defp model, do: env("MAVE_AUDIO_DESCRIPTION_MODEL", @default_model)
+  defp endpoint, do: env("MAVE_AUDIO_DESCRIPTION_ENDPOINT", @endpoint)
+
+  defp reasoning_effort do
+    case env("MAVE_AUDIO_DESCRIPTION_REASONING_EFFORT", "none") do
+      "" -> nil
+      value -> value
+    end
+  end
+
+  defp env(name, default) do
+    case System.get_env(name) do
+      value when is_binary(value) and value != "" -> String.trim(value)
+      _ -> default
+    end
+  end
+
+  defp maybe_put(map, _key, nil), do: map
+  defp maybe_put(map, key, value), do: Map.put(map, key, value)
+
+  defp truncate(body) when is_binary(body), do: String.slice(body, 0, 600)
+  defp truncate(body), do: body |> inspect() |> String.slice(0, 600)
+end
diff --git a/lib/mave_core/audio_description/timeline.ex b/lib/mave_core/audio_description/timeline.ex
new file mode 100644
index 0000000..8935c42
--- /dev/null
+++ b/lib/mave_core/audio_description/timeline.ex
@@ -0,0 +1,360 @@
+defmodule MaveCore.AudioDescription.Timeline do
+  @moduledoc """
+  Pure timing logic for audio descriptions: where speech is, which scenes the
+  video has, and where each spoken description goes.
+
+  Descriptions play in the pauses of the original speech. When one doesn't fit a
+  nearby pause it plays at its own moment and the original audio is ducked under
+  it. A description always stays with its scene: it starts while the scene is on
+  screen and at least half of it is spoken during the scene.
+
+  Intervals are maps `%{start: seconds, end: seconds}`. All results are rounded
+  to milliseconds.
+  """
+
+  # Words closer together than this belong to the same stretch of speech.
+  @merge_gap_seconds 0.5
+  # Margin kept around speech, so a description never clips a syllable.
+  @speech_pad_seconds 0.15
+  # How far a description may move away from its moment to fit in a pause.
+  @max_shift_later 2.0
+  @max_shift_earlier 1.0
+  # Silence between two consecutive descriptions.
+  @breath_seconds 0.15
+  # Shortest scene: quick cuts are grouped until a scene is at least this long.
+  @min_scene_seconds 3.0
+  @epsilon 1.0e-9
+
+  def min_scene_seconds, do: @min_scene_seconds
+
+  @doc "Padded, merged stretches of speech within `[0, duration]` from word or segment timings."
+  def speech_from_words(
+        words,
+        duration,
+        merge_gap \\ @merge_gap_seconds,
+        pad \\ @speech_pad_seconds
+      ) do
+    words
+    |> Enum.filter(&(&1.end > &1.start))
+    |> Enum.sort_by(& &1.start)
+    |> Enum.reduce([], fn word, acc ->
+      case acc do
+        [prev | rest] when word.start - prev.end <= merge_gap ->
+          [%{prev | end: max(prev.end, word.end)} | rest]
+
+        _ ->
+          [%{start: word.start, end: word.end} | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> Enum.reduce([], fn stretch, acc ->
+      start = max(0.0, stretch.start - pad)
+      stop = min(duration * 1.0, stretch.end + pad)
+
+      cond do
+        stop <= start -> acc
+        match?([prev | _] when start <= prev.end, acc) -> merge_into_head(acc, stop)
+        true -> [%{start: start, end: stop} | acc]
+      end
+    end)
+    |> Enum.reverse()
+    |> Enum.map(&round_interval/1)
+  end
+
+  defp merge_into_head([prev | rest], stop), do: [%{prev | end: max(prev.end, stop)} | rest]
+
+  @doc "The pauses between speech, within `[0, duration]`."
+  def free_gaps(speech, duration) do
+    duration = duration * 1.0
+
+    {gaps, cursor} =
+      Enum.reduce_while(speech, {[], 0.0}, fn stretch, {gaps, cursor} ->
+        gaps =
+          if stretch.start > cursor,
+            do: [%{start: cursor, end: min(stretch.start, duration)} | gaps],
+            else: gaps
+
+        cursor = max(cursor, stretch.end)
+        if cursor >= duration, do: {:halt, {gaps, cursor}}, else: {:cont, {gaps, cursor}}
+      end)
+
+    gaps = if cursor < duration, do: [%{start: cursor, end: duration} | gaps], else: gaps
+
+    gaps
+    |> Enum.reverse()
+    |> Enum.filter(&(&1.end - &1.start > 0.001))
+    |> Enum.map(&round_interval/1)
+  end
+
+  @doc "Shot intervals from cut times."
+  def shots_from_cuts(cuts, duration) do
+    inner = cuts |> Enum.filter(&(&1 > 0 and &1 < duration)) |> Enum.sort()
+
+    ([0.0 | inner] ++ [duration * 1.0])
+    |> Enum.chunk_every(2, 1, :discard)
+    |> Enum.filter(fn [a, b] -> b > a end)
+    |> Enum.map(fn [a, b] -> round_interval(%{start: a, end: b}) end)
+  end
+
+  @doc """
+  Group consecutive short shots into scenes of at least `min_seconds`, so a fast
+  montage gets described (what its cuts show together) instead of not at all. A
+  short remainder at the end joins the scene before it.
+  """
+  def scenes_from_shots(shots, min_seconds \\ @min_scene_seconds) do
+    {scenes, current} =
+      Enum.reduce(shots, {[], nil}, fn shot, {scenes, current} ->
+        current = if current, do: %{current | end: shot.end}, else: Map.take(shot, [:start, :end])
+
+        if current.end - current.start >= min_seconds,
+          do: {[current | scenes], nil},
+          else: {scenes, current}
+      end)
+
+    scenes =
+      case {current, scenes} do
+        {nil, _} -> scenes
+        {current, []} -> [current]
+        {current, [last | rest]} -> [%{last | end: current.end} | rest]
+      end
+
+    scenes |> Enum.reverse() |> Enum.map(&round_interval/1)
+  end
+
+  @doc "Words a description can have to be spoken within `seconds` (about 2.5 words per second)."
+  def word_budget(seconds), do: max(0, floor((seconds - 0.2) * 2.5))
+
+  @doc """
+  Scenes, speech and numbered pauses (with a word budget each) as context for the
+  description model. With a `window`, only what overlaps it is listed, keeping the
+  global numbers.
+  """
+  def timing_prompt(speech, scenes, duration, window \\ nil) do
+    gaps = free_gaps(speech, duration)
+    in_window? = fn i -> is_nil(window) or (i.start < window.end and i.end > window.start) end
+
+    scene_lines =
+      scenes
+      |> Enum.with_index()
+      |> Enum.filter(fn {scene, _} -> in_window?.(scene) end)
+      |> Enum.map(fn {scene, i} -> "S#{i}: #{format_interval(scene)}" end)
+
+    gap_lines =
+      gaps
+      |> Enum.with_index()
+      |> Enum.filter(fn {gap, _} -> in_window?.(gap) end)
+      |> Enum.map(fn {gap, i} ->
+        length = gap.end - gap.start
+
+        "P#{i}: #{format_interval(gap)} (#{format_decimal(length, 1)} s, max #{word_budget(length)} words)"
+      end)
+
+    speech_in_window = Enum.filter(speech, in_window?)
+
+    speech_line =
+      if speech_in_window == [],
+        do: "none",
+        else: Enum.map_join(speech_in_window, ", ", &format_interval/1)
+
+    Enum.join(
+      ["Scenes (index: seconds), from cut detection; quick cuts are grouped into one scene:"] ++
+        if(scenes == [], do: ["S0: the whole video"], else: scene_lines) ++
+        [
+          "Speech (seconds): #{speech_line}",
+          "Pauses without speech (index: seconds, length, max words):"
+        ] ++ if(gap_lines == [], do: ["none"], else: gap_lines),
+      "\n"
+    )
+  end
+
+  @doc """
+  Stills for image-only vision models: at least one per camera shot, and one per
+  `every` seconds in longer shots, spread inside the shot (never on the cut). Each
+  still carries the index of the scene it belongs to.
+  """
+  def plan_stills(scenes, duration, every \\ 3, cuts \\ nil) do
+    cuts = cuts || scenes
+    list = if cuts == [], do: [%{start: 0.0, end: duration * 1.0}], else: cuts
+
+    Enum.flat_map(list, &shot_stills(&1, scenes, every))
+  end
+
+  defp shot_stills(%{start: start, end: stop}, _scenes, _every) when stop <= start, do: []
+
+  defp shot_stills(shot, scenes, every) do
+    length = shot.end - shot.start
+    count = max(1, round(length / every))
+
+    for k <- 0..(count - 1) do
+      time = round3(shot.start + (k + 0.5) * length / count)
+      %{scene: scene_index(scenes, time), time: time}
+    end
+  end
+
+  defp scene_index(scenes, time) do
+    Enum.find_index(scenes, &(time >= &1.start and time < &1.end)) ||
+      max(0, length(scenes) - 1)
+  end
+
+  @doc "Stills in batches of at most `max` (the provider's image limit per prompt)."
+  def batch_stills(stills, max \\ 12), do: Enum.chunk_every(stills, max)
+
+  @doc """
+  Pin each cue to the scene it describes and, when the model chose one, the pause
+  it goes in. A pause that doesn't overlap the scene is ignored (the description
+  would be out of sync); `-1` means during speech.
+  """
+  def snap_cues(cues, gaps, scenes), do: Enum.map(cues, &snap_cue(&1, gaps, scenes))
+
+  defp snap_cue(cue, gaps, scenes) do
+    scene = cue_scene(cue, scenes)
+    {lo, hi} = cue_bounds(scene, indexed(gaps, cue[:pause]))
+    start = min_inf(max(cue.start, lo), max_inf(lo, sub_inf(hi, 0.3)))
+    stop = min_inf(hi, max(cue.end, start + 0.5))
+
+    %{start: round3(start), end: round3(max(stop, start + 0.1)), text: cue.text}
+    |> put_scene(scene)
+  end
+
+  defp cue_scene(cue, scenes) do
+    indexed(scenes, cue[:scene]) ||
+      Enum.find(scenes, &(cue.start >= &1.start and cue.start < &1.end))
+  end
+
+  defp indexed(list, index) when is_integer(index) and index >= 0, do: Enum.at(list, index)
+  defp indexed(_list, _index), do: nil
+
+  # Within the scene; within the chosen pause too when that pause overlaps the scene.
+  defp cue_bounds(nil, gap), do: narrow_to_gap({0.0, :infinity}, gap)
+  defp cue_bounds(scene, gap), do: narrow_to_gap({scene.start, scene.end}, gap)
+
+  defp narrow_to_gap({lo, hi}, %{start: gap_start, end: gap_end}) do
+    if lt?(gap_start, hi) and gap_end > lo,
+      do: {max(lo, gap_start), min_inf(hi, gap_end)},
+      else: {lo, hi}
+  end
+
+  defp narrow_to_gap(bounds, nil), do: bounds
+
+  @doc """
+  Place every spoken description. `lengths` are clip lengths in samples.
+
+  Returns `%{placements: [%{index, start, length}], cues: [...], ducks: [...],
+  skipped: [index], total_samples: n}`. `cues` are timed to when each description
+  is actually spoken; `ducks` are where the original audio is lowered.
+  """
+  def plan_timeline(cues, lengths, speech, duration, sample_rate) do
+    gaps = free_gaps(speech, duration)
+    duration = duration * 1.0
+
+    initial = %{cursor: 0.0, placements: [], cues: [], ducks: [], skipped: []}
+
+    state =
+      cues
+      |> Enum.with_index()
+      |> Enum.reduce(initial, fn {cue, index}, state ->
+        length = Enum.at(lengths, index) || 0
+
+        if length <= 0,
+          do: state,
+          else: place(cue, index, length, sample_rate, gaps, speech, duration, state)
+      end)
+
+    timed = Enum.reverse(state.cues)
+    last_end = if timed == [], do: 0.0, else: List.last(timed).end
+
+    %{
+      placements: Enum.reverse(state.placements),
+      cues: timed,
+      ducks: Enum.reverse(state.ducks),
+      skipped: Enum.reverse(state.skipped),
+      total_samples: round(max(duration, last_end) * sample_rate)
+    }
+  end
+
+  defp place(cue, index, length, sample_rate, gaps, speech, duration, state) do
+    seconds = length / sample_rate
+    scene = cue[:scene]
+    scene_start = if scene, do: scene.start, else: :neg_infinity
+    latest_start = if scene, do: scene.end - seconds / 2, else: :infinity
+
+    case pause_start(cue, seconds, gaps, state.cursor, scene_start, latest_start) do
+      nil -> place_over_speech(cue, index, length, seconds, sample_rate, speech, duration, state)
+      start -> put_placement(state, cue, index, length, start, seconds, sample_rate, false)
+    end
+  end
+
+  # 1. A pause near the cue, within its scene, that holds the whole clip.
+  defp pause_start(cue, seconds, gaps, cursor, scene_start, latest_start) do
+    gaps
+    |> Enum.flat_map(fn gap ->
+      lo = Enum.max([gap.start, cursor, cue.start - @max_shift_earlier, num(scene_start)])
+      hi = min_inf(min(gap.end - seconds, cue.start + @max_shift_later), latest_start)
+      if lo > hi + @epsilon, do: [], else: [min(max(cue.start, lo), hi)]
+    end)
+    |> Enum.min_by(&abs(&1 - cue.start), fn -> nil end)
+  end
+
+  # 2. Otherwise at its own moment in the scene (after the previous description), over the speech.
+  defp place_over_speech(cue, index, length, seconds, sample_rate, speech, duration, state) do
+    scene = cue[:scene]
+    latest_start = if scene, do: scene.end - seconds / 2, else: :infinity
+    start = Enum.max([cue.start, state.cursor, if(scene, do: scene.start, else: cue.start)])
+    start = if start + seconds > duration, do: max(state.cursor, duration - seconds), else: start
+
+    if gt_inf?(start, latest_start) or start + seconds > duration + 0.5 do
+      %{state | skipped: [index | state.skipped]}
+    else
+      ducked? = Enum.any?(speech, &(start < &1.end and &1.start < start + seconds))
+      put_placement(state, cue, index, length, start, seconds, sample_rate, ducked?)
+    end
+  end
+
+  defp put_placement(state, cue, index, length, start, seconds, sample_rate, ducked?) do
+    stop = start + seconds
+    timed = %{start: round3(start), end: round3(stop), text: cue.text} |> put_scene(cue[:scene])
+    duck = %{start: round3(start), end: round3(stop)}
+
+    %{
+      state
+      | cursor: stop + @breath_seconds,
+        placements: [
+          %{index: index, start: round(start * sample_rate), length: length} | state.placements
+        ],
+        cues: [timed | state.cues],
+        ducks: if(ducked?, do: [duck | state.ducks], else: state.ducks)
+    }
+  end
+
+  defp put_scene(cue, nil), do: cue
+  defp put_scene(cue, scene), do: Map.put(cue, :scene, Map.take(scene, [:start, :end]))
+
+  defp num(:neg_infinity), do: -1.0e18
+  defp num(value), do: value
+
+  defp min_inf(:infinity, b), do: b
+  defp min_inf(a, :infinity), do: a
+  defp min_inf(a, b), do: min(a, b)
+
+  defp max_inf(_a, :infinity), do: :infinity
+  defp max_inf(a, b), do: max(a, b)
+
+  defp sub_inf(:infinity, _b), do: :infinity
+  defp sub_inf(a, b), do: a - b
+
+  defp lt?(_a, :infinity), do: true
+  defp lt?(a, b), do: a < b
+
+  defp gt_inf?(_a, :infinity), do: false
+  defp gt_inf?(a, b), do: a > b + @epsilon
+
+  defp round_interval(%{start: start, end: stop}), do: %{start: round3(start), end: round3(stop)}
+
+  @doc false
+  def round3(value), do: Float.round(value * 1.0, 3)
+
+  defp format_interval(i), do: "#{format_decimal(i.start, 2)}-#{format_decimal(i.end, 2)}"
+
+  defp format_decimal(value, decimals),
+    do: :erlang.float_to_binary(value * 1.0, decimals: decimals)
+end
diff --git a/lib/mave_core/audio_description/wav.ex b/lib/mave_core/audio_description/wav.ex
new file mode 100644
index 0000000..f3bf5f2
--- /dev/null
+++ b/lib/mave_core/audio_description/wav.ex
@@ -0,0 +1,169 @@
+defmodule MaveCore.AudioDescription.Wav do
+  @moduledoc """
+  Speech clips from text-to-speech, normalized to mono signed 16-bit
+  little-endian PCM at `sample_rate/0` with leading and trailing silence trimmed.
+  """
+
+  import Bitwise
+
+  @sample_rate 24_000
+
+  def sample_rate, do: @sample_rate
+
+  @doc """
+  Decode RIFF/WAVE bytes (PCM 8/16/24/32-bit or 32-bit float, any channel count)
+  to `{samples, sample_rate}`, where `samples` is mono s16le. Bytes without a RIFF
+  header are taken as raw s16le mono at 24 kHz.
+  """
+  def decode(<<"RIFF", _size::little-32, "WAVE", chunks::binary>>) do
+    with {:ok, format, data} <- read_chunks(chunks, nil) do
+      {:ok, {downmix(data, format), format.sample_rate}}
+    end
+  end
+
+  def decode(bytes) when is_binary(bytes) do
+    even = byte_size(bytes) - rem(byte_size(bytes), 2)
+    {:ok, {binary_part(bytes, 0, even), @sample_rate}}
+  end
+
+  defp read_chunks(<<"fmt ", size::little-32, body::binary-size(size), rest::binary>>, _format) do
+    <<tag::little-16, channels::little-16, rate::little-32, _byte_rate::little-32,
+      _align::little-16, bits::little-16, extra::binary>> = body
+
+    tag =
+      case {tag, extra} do
+        {0xFFFE,
+         <<_cb::little-16, _valid::little-16, _mask::little-32, sub::little-16, _::binary>>} ->
+          sub
+
+        {tag, _} ->
+          tag
+      end
+
+    read_chunks(skip_pad(rest, size), %{
+      tag: tag,
+      channels: channels,
+      sample_rate: rate,
+      bits: bits
+    })
+  end
+
+  defp read_chunks(<<"data", size::little-32, rest::binary>>, %{} = format) do
+    # Streamed WAVs may carry 0 or 0xFFFFFFFF as size; use what is there.
+    size = if size in [0, 0xFFFFFFFF] or size > byte_size(rest), do: byte_size(rest), else: size
+    {:ok, format, binary_part(rest, 0, size)}
+  end
+
+  defp read_chunks(<<_id::binary-size(4), size::little-32, rest::binary>>, format)
+       when byte_size(rest) >= size do
+    read_chunks(skip_pad(binary_part(rest, size, byte_size(rest) - size), size), format)
+  end
+
+  defp read_chunks(_rest, _format), do: {:error, :invalid_wav}
+
+  defp skip_pad(<<_pad, rest::binary>>, size) when rem(size, 2) == 1, do: rest
+  defp skip_pad(rest, _size), do: rest
+
+  defp downmix(data, %{tag: tag, channels: channels, bits: bits}) do
+    bytes = div(bits, 8)
+    frame = bytes * channels
+
+    for <<frame_bytes::binary-size(^frame) <- data>>, into: <<>> do
+      sum =
+        for <<sample::binary-size(^bytes) <- frame_bytes>>, reduce: 0 do
+          acc -> acc + read_sample(sample, tag, bits)
+        end
+
+      <<clamp(round(sum / channels))::little-signed-16>>
+    end
+  end
+
+  defp read_sample(<<value::little-float-32>>, 3, 32), do: max(-1.0, min(1.0, value)) * 32_767
+  defp read_sample(<<value>>, _tag, 8), do: (value - 128) <<< 8
+  defp read_sample(<<value::little-signed-16>>, _tag, 16), do: value
+  defp read_sample(<<value::little-signed-24>>, _tag, 24), do: value >>> 8
+  defp read_sample(<<value::little-signed-32>>, _tag, 32), do: value >>> 16
+
+  @doc "Linear-interpolation resample of s16le mono samples."
+  def resample(samples, from_rate, to_rate \\ @sample_rate)
+  def resample(samples, rate, rate), do: samples
+
+  def resample(samples, from_rate, to_rate) do
+    input = for <<s::little-signed-16 <- samples>>, do: s
+    tuple = List.to_tuple(input)
+    count = tuple_size(tuple)
+    ratio = from_rate / to_rate
+    length = floor(count / ratio)
+
+    if length == 0 do
+      <<>>
+    else
+      for i <- 0..(length - 1), into: <<>> do
+        pos = i * ratio
+        i0 = floor(pos)
+        i1 = min(i0 + 1, count - 1)
+        t = pos - i0
+        <<round(elem(tuple, i0) * (1 - t) + elem(tuple, i1) * t)::little-signed-16>>
+      end
+    end
+  end
+
+  @doc "Trim leading and trailing near-silence, keeping a little padding."
+  def trim_silence(samples, sample_rate \\ @sample_rate, threshold \\ 400, pad_seconds \\ 0.05) do
+    count = div(byte_size(samples), 2)
+
+    case first_loud(samples, threshold) do
+      nil ->
+        <<>>
+
+      first ->
+        last = last_loud(samples, count, threshold)
+        pad = round(pad_seconds * sample_rate)
+        from = max(0, first - pad)
+        to = min(count, last + 1 + pad)
+        binary_part(samples, from * 2, (to - from) * 2)
+    end
+  end
+
+  defp first_loud(samples, threshold) do
+    Enum.find_value(0..(div(byte_size(samples), 2) - 1)//1, fn i ->
+      offset = i * 2
+      <<_::binary-size(^offset), s::little-signed-16, _::binary>> = samples
+      if abs(s) >= threshold, do: i
+    end)
+  end
+
+  defp last_loud(samples, count, threshold) do
+    Enum.find_value((count - 1)..0//-1, fn i ->
+      offset = i * 2
+      <<_::binary-size(^offset), s::little-signed-16, _::binary>> = samples
+      if abs(s) >= threshold, do: i
+    end)
+  end
+
+  @doc "Decode TTS output into a trimmed mono s16le clip at `sample_rate/0`."
+  def clip(bytes) do
+    with {:ok, {samples, rate}} <- decode(bytes) do
+      {:ok, samples |> resample(rate, @sample_rate) |> trim_silence(@sample_rate)}
+    end
+  end
+
+  @doc "Silence and clips laid out on one timeline, as s16le iodata."
+  def render(placements, total_samples, load_clip) do
+    {parts, position} =
+      Enum.reduce(placements, {[], 0}, fn %{index: index, start: start, length: length},
+                                          {parts, position} ->
+        clip = load_clip.(index)
+        clip = binary_part(clip, 0, min(byte_size(clip), length * 2))
+        silence = silence(max(0, start - position))
+        {[clip, silence | parts], max(position, start) + div(byte_size(clip), 2)}
+      end)
+
+    Enum.reverse([silence(max(0, total_samples - position)) | parts])
+  end
+
+  defp silence(0), do: <<>>
+  defp silence(samples), do: :binary.copy(<<0, 0>>, samples)
+
+  defp clamp(value), do: value |> max(-32_768) |> min(32_767)
+end
diff --git a/lib/mave_core/embeds.ex b/lib/mave_core/embeds.ex
index 18eda64..90a7ce7 100644
--- a/lib/mave_core/embeds.ex
+++ b/lib/mave_core/embeds.ex
@@ -598,12 +598,43 @@ defmodule MaveCore.Embeds do
           audio_only?
         ),
       audio_tracks: audio_tracks,
+      audio_descriptions:
+        audio_descriptions_for(space, video_embed, current_video, current_version),
       subtitles: subtitles_for(space, video_embed, current_video, current_version),
       renditions: renditions_for(current_video, flow_run),
       flow: flow_summary_for(flow_run)
     }
   end
 
+  defp audio_descriptions_for(_space, _embed, nil, _version), do: []
+
+  defp audio_descriptions_for(%Space{} = space, %Embed{} = embed, %Video{id: video_id}, version) do
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    video_id
+    |> MaveCore.Assets.list_audio_descriptions()
+    |> Enum.map(fn description ->
+      serialized =
+        ManifestPublisher.serialize_audio_description(description, bucket, embed.hash, version)
+
+      %{
+        id: description.id,
+        language: description.language,
+        label:
+          description.label || Languages.spoken_language(description.language) ||
+            String.upcase(description.language),
+        default: false,
+        codec: "mp3",
+        mp3_url: get_in(serialized, ["audio", "path"]),
+        hls_playlist: get_in(serialized, ["audio", "hls_playlist"]),
+        vtt_url: get_in(serialized, ["vtt", "path"]),
+        cue_count: description.cue_count
+      }
+    end)
+  end
+
+  defp audio_descriptions_for(_space, _embed, _video, _version), do: []
+
   defp dashboard_payload_analytics(payload) do
     %{
       views: %{
diff --git a/lib/mave_core/embeds/manifest_publisher.ex b/lib/mave_core/embeds/manifest_publisher.ex
index c2aa4b4..62d0b65 100644
--- a/lib/mave_core/embeds/manifest_publisher.ex
+++ b/lib/mave_core/embeds/manifest_publisher.ex
@@ -3,7 +3,8 @@ defmodule MaveCore.Embeds.ManifestPublisher do
 
   import Ecto.Query
 
-  alias MaveCore.Assets.{AudioTrack, Video}
+  alias MaveCore.Assets
+  alias MaveCore.Assets.{AudioDescription, AudioTrack, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, SettingsSerializer}
   alias MaveCore.Languages
@@ -110,6 +111,7 @@ defmodule MaveCore.Embeds.ManifestPublisher do
           hls_ready?
         )
     }
+    |> maybe_put("audio_descriptions", manifest_audio_descriptions(embed, version))
   end
 
   defp manifest_waveform(opts, manifest, version) do
@@ -588,6 +590,53 @@ defmodule MaveCore.Embeds.ManifestPublisher do
     "#{embed_hash}/#{filename}"
   end
 
+  # Omitted when there are none, so manifests without audio description don't change.
+  defp manifest_audio_descriptions(%Embed{} = embed, version) do
+    case current_video(embed) do
+      %Video{id: video_id} ->
+        bucket = Storage.bucket_for_space(embed.space.hash, embed.space.region)
+
+        video_id
+        |> Assets.list_audio_descriptions()
+        |> Enum.map(&serialize_audio_description(&1, bucket, embed.hash, version))
+        |> case do
+          [] -> nil
+          descriptions -> descriptions
+        end
+
+      _ ->
+        nil
+    end
+  end
+
+  @doc false
+  def serialize_audio_description(%AudioDescription{} = description, bucket, embed_hash, version) do
+    %{
+      "language" => description.language,
+      "label" => AudioDescription.display_label(description),
+      "audio" => %{
+        "path" =>
+          SettingsSerializer.storage_object_url(
+            bucket,
+            audio_track_key(embed_hash, version, description.audio_filename)
+          ),
+        "hls_playlist" => AudioDescription.hls_playlist(description),
+        "file_size" => description.audio_file_size
+      },
+      "vtt" =>
+        if(description.vtt_filename,
+          do: %{
+            "path" =>
+              SettingsSerializer.storage_object_url(
+                bucket,
+                audio_track_key(embed_hash, version, description.vtt_filename)
+              ),
+            "file_size" => description.vtt_file_size
+          }
+        )
+    }
+  end
+
   defp manifest_subtitles(%Embed{} = embed, version) do
     bucket = Storage.bucket_for_space(embed.space.hash, embed.space.region)
 
diff --git a/lib/mave_core/flow.ex b/lib/mave_core/flow.ex
index 8a0a266..36e8229 100644
--- a/lib/mave_core/flow.ex
+++ b/lib/mave_core/flow.ex
@@ -7,7 +7,7 @@ defmodule MaveCore.Flow do
 
   alias Ecto.Adapters.SQL
   alias MaveCore.Assets
-  alias MaveCore.Assets.{Asset, AudioTrack, Rendition, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle, Video}
   alias MaveCore.Embeds
   alias MaveCore.Embeds.{Embed, ManifestPublisher, PlayerPublisher}
   alias MaveCore.Embeds.Events, as: EmbedEvents
@@ -67,10 +67,12 @@ defmodule MaveCore.Flow do
   @failed_run_pending_step_error "not executed because flow run failed"
   @default_flame_pool MaveCore.Workers.FlameRunner
   @media_step_types ~w(
+    media.detect_scenes
     media.extract_frame
     media.generate_audio_peaks
     media.generate_segments
     media.generate_storyboard
+    media.mix_audio_description
     media.package_hls_audio
     media.package_hls_variant
     media.transcode_audio
@@ -4550,6 +4552,7 @@ defmodule MaveCore.Flow do
                 "media.generate_audio_peaks",
                 "ai.transcribe_audio",
                 "ai.translate_subtitles",
+                "media.mix_audio_description",
                 "manifest.build"
               ] do
     with %Run{input: %{"space_hash" => space_hash, "embed_hash" => embed_hash}} = run <-
@@ -4561,6 +4564,9 @@ defmodule MaveCore.Flow do
         "media.transcode_audio" ->
           sync_audio_tracks(video.id, step_runs)
 
+        "media.mix_audio_description" ->
+          sync_audio_descriptions(video.id, step_runs)
+
         subtitle_step when subtitle_step in ["ai.transcribe_audio", "ai.translate_subtitles"] ->
           sync_subtitles(video.id, step_runs)
 
@@ -4637,7 +4643,12 @@ defmodule MaveCore.Flow do
   end
 
   defp maybe_refresh_completed_hls_master(step_type, %Embed{} = embed)
-       when step_type in ["ai.transcribe_audio", "ai.translate_subtitles", "manifest.build"] do
+       when step_type in [
+              "ai.transcribe_audio",
+              "ai.translate_subtitles",
+              "media.mix_audio_description",
+              "manifest.build"
+            ] do
     Assets.refresh_hls_master_playlist(embed)
   end
 
@@ -4775,6 +4786,46 @@ defmodule MaveCore.Flow do
     end)
   end
 
+  # Upserts per language, so a run that skipped audio description (or one language of
+  # it) keeps the descriptions this video version already has.
+  defp sync_audio_descriptions(video_id, step_runs) when is_binary(video_id) do
+    Enum.each(step_runs, fn
+      %StepRun{
+        step_type: "media.mix_audio_description",
+        status: "succeeded",
+        output: %{"status" => "ok", "audio_description" => %{} = description}
+      } ->
+        %AudioDescription{}
+        |> AudioDescription.changeset(
+          description
+          |> Map.put("video_id", video_id)
+          |> Map.put("generation_language", description["language"])
+        )
+        |> Repo.insert!(
+          on_conflict:
+            from(existing in AudioDescription,
+              where: not existing.user_managed and is_nil(existing.deleted_at),
+              update: [
+                set: [
+                  audio_filename: fragment("EXCLUDED.audio_filename"),
+                  audio_file_size: fragment("EXCLUDED.audio_file_size"),
+                  vtt_filename: fragment("EXCLUDED.vtt_filename"),
+                  vtt_file_size: fragment("EXCLUDED.vtt_file_size"),
+                  cue_count: fragment("EXCLUDED.cue_count"),
+                  ducked_cue_count: fragment("EXCLUDED.ducked_cue_count"),
+                  updated_at: fragment("EXCLUDED.updated_at")
+                ]
+              ]
+            ),
+          conflict_target: [:video_id, :generation_language],
+          allow_stale: true
+        )
+
+      _step_run ->
+        :ok
+    end)
+  end
+
   defp sync_subtitles(video_id, step_runs) when is_binary(video_id) do
     from(subtitle in Subtitle, where: subtitle.video_id == ^video_id)
     |> Repo.delete_all()
@@ -5166,6 +5217,7 @@ defmodule MaveCore.Flow do
     sync_video_renditions(video.id, step_runs)
     sync_audio_tracks(video.id, step_runs)
     sync_subtitles(video.id, step_runs)
+    sync_audio_descriptions(video.id, step_runs)
     maybe_apply_detected_audio_track_language(video.id, step_runs)
   end
 
diff --git a/lib/mave_core/flow/presets.ex b/lib/mave_core/flow/presets.ex
index c85bd1f..af4eda8 100644
--- a/lib/mave_core/flow/presets.ex
+++ b/lib/mave_core/flow/presets.ex
@@ -31,7 +31,8 @@ defmodule MaveCore.Flow.Presets do
        "name" => "Publish Default",
        "description" =>
          "Encoder-compatible default publish flow with upload, transcode, manifest, and webhook steps.",
-       "definition" => publish_default_definition() |> with_audio_peaks()
+       "definition" =>
+         publish_default_definition() |> with_audio_peaks() |> with_audio_description()
      }
      |> maybe_override_preset("publish_default")}
   end
@@ -43,7 +44,8 @@ defmodule MaveCore.Flow.Presets do
        "name" => "Publish Local",
        "description" =>
          "Lighter local-development publish flow that skips heavy codec variants while still producing a manifest.",
-       "definition" => publish_local_definition() |> with_audio_peaks()
+       "definition" =>
+         publish_local_definition() |> with_audio_peaks() |> with_audio_description()
      }
      |> maybe_override_preset("publish_local")}
   end
@@ -83,7 +85,10 @@ defmodule MaveCore.Flow.Presets do
         step -> step
       end)
 
-    definition |> Map.put("steps", durable_steps) |> with_audio_peaks()
+    definition
+    |> Map.put("steps", durable_steps)
+    |> with_audio_peaks()
+    |> with_audio_description()
   end
 
   defp with_audio_peaks(definition) do
@@ -104,6 +109,46 @@ defmodule MaveCore.Flow.Presets do
     )
   end
 
+  # A single original-language track is generated in the background.
+  defp with_audio_description(definition) do
+    steps = [
+      background_step("detect_scenes", "media.detect_scenes", "Detect Scenes", ["inspect_media"]),
+      background_step("describe_video", "ai.describe_video", "Describe Video", [
+        "detect_scenes",
+        "transcribe_audio",
+        "transcode_audio"
+      ]),
+      background_step(
+        "speak_descriptions_original",
+        "ai.speak_descriptions",
+        "Speak Descriptions",
+        ["describe_video"],
+        %{"language" => "original", "source_step_id" => "describe_video"}
+      ),
+      background_step(
+        "mix_audio_description_original",
+        "media.mix_audio_description",
+        "Mix Audio Description",
+        ["speak_descriptions_original", "transcode_audio"],
+        %{"language" => "original", "source_step_id" => "speak_descriptions_original"}
+      )
+    ]
+
+    Map.update!(definition, "steps", &(&1 ++ steps))
+  end
+
+  defp background_step(id, type, name, depends_on, params \\ nil) do
+    %{
+      "id" => id,
+      "type" => type,
+      "name" => name,
+      "depends_on" => depends_on,
+      "lane" => "background",
+      "required" => false
+    }
+    |> then(fn step -> if params, do: Map.put(step, "params", params), else: step end)
+  end
+
   defp maybe_override_preset(preset, slug) do
     case Application.get_env(:mave_core, :flow_preset_overrides, %{}) do
       overrides when is_map(overrides) ->
diff --git a/lib/mave_core/flow/step_registry.ex b/lib/mave_core/flow/step_registry.ex
index 8b60022..74a6beb 100644
--- a/lib/mave_core/flow/step_registry.ex
+++ b/lib/mave_core/flow/step_registry.ex
@@ -4,18 +4,23 @@ defmodule MaveCore.Flow.StepRegistry do
   """
 
   alias MaveCore.Flow.Steps.{
+    AiDescribeVideoStep,
+    AiSpeakDescriptionsStep,
     AiTranscribeAudioStep,
+    AiTranslateDescriptionsStep,
     AiTranslateSubtitlesStep,
     AssetUploadOriginalStep,
     CdnPurgeStep,
     EventNotifyWebhookStep,
     ManifestBuildStep,
     MediaBuildHlsMasterStep,
+    MediaDetectScenesStep,
     MediaExtractFrameStep,
     MediaGenerateAudioPeaksStep,
     MediaGenerateSegmentsStep,
     MediaGenerateStoryboardStep,
     MediaInspectStep,
+    MediaMixAudioDescriptionStep,
     MediaPackageHlsAudioStep,
     MediaPackageHlsVariantStep,
     MediaTranscodeAudioStep,
@@ -167,6 +172,49 @@ defmodule MaveCore.Flow.StepRegistry do
       options: [@strict_option],
       executor: :inline
     },
+    "media.detect_scenes" => %{
+      name: "Detect Scenes",
+      category: "media",
+      description:
+        "Detects camera cuts, groups them into scenes and extracts labelled stills for audio description.",
+      handler: MediaDetectScenesStep,
+      options: [@strict_option],
+      executor: :flame
+    },
+    "ai.describe_video" => %{
+      name: "Describe Video",
+      category: "ai",
+      description:
+        "Writes English audio description cues for the scenes, placed in the pauses of the speech.",
+      handler: AiDescribeVideoStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "ai.translate_descriptions" => %{
+      name: "Translate Descriptions",
+      category: "ai",
+      description: "Translates the English audio description cues into another language.",
+      handler: AiTranslateDescriptionsStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "ai.speak_descriptions" => %{
+      name: "Speak Descriptions",
+      category: "ai",
+      description: "Speaks the audio description cues of one language with text-to-speech.",
+      handler: AiSpeakDescriptionsStep,
+      options: [@strict_option],
+      executor: :inline
+    },
+    "media.mix_audio_description" => %{
+      name: "Mix Audio Description",
+      category: "media",
+      description:
+        "Mixes the spoken descriptions into the video's audio (ducked under speech) and writes the descriptions VTT.",
+      handler: MediaMixAudioDescriptionStep,
+      options: [@strict_option],
+      executor: :flame
+    },
     "subtitle.upload" => %{
       name: "Upload Subtitle",
       category: "subtitle",
diff --git a/lib/mave_core/flow/steps/ai_describe_video_step.ex b/lib/mave_core/flow/steps/ai_describe_video_step.ex
new file mode 100644
index 0000000..63059ae
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_describe_video_step.ex
@@ -0,0 +1,242 @@
+defmodule MaveCore.Flow.Steps.AiDescribeVideoStep do
+  @moduledoc """
+  Writes the original-language audio description cues from the labelled stills of
+  `media.detect_scenes`, around the speech measured by speech-to-text.
+
+  Speech comes from the `ai.transcribe_audio` segments (never from the description
+  model); when that step has none, this step transcribes the audio itself. The
+  cues are the source for the spoken description.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription.{Cues, Prompts, Timeline}
+  alias MaveCore.Embeds.SettingsSerializer
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.describe_video"
+  # Scaleway's vision models accept at most this many images per prompt.
+  @max_images 12
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, scenes_output} <- AD.check_dependency(ctx, AD.source_step_id(ctx, "detect_scenes")) do
+      describe(ctx, scenes_output)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason), []}
+    end
+  end
+
+  defp describe(ctx, scenes_output) do
+    with {:ok, document} <- AD.get_json(ctx, scenes_output["scenes_key"]),
+         duration = document["duration"] * 1.0,
+         {:ok, speech} <- speech(ctx, duration),
+         scenes = intervals(document["scenes"]),
+         {:ok, raw_cues} <- describe_batches(ctx, document["stills"], scenes, speech, duration),
+         cues = clean_cues(raw_cues, speech, scenes, duration),
+         :ok <- require_cues(cues),
+         language = AD.language(ctx),
+         {:ok, cues_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "#{language}/cues.json"), Cues.to_json(cues)),
+         {:ok, speech_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "speech.json"), Enum.map(speech, &interval_json/1)),
+         {:ok, _} <- AD.put_json(ctx, AD.work_key(ctx, "raw-cues.json"), raw_cues) do
+      {:ok,
+       %{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "cues_key" => cues_key,
+         "speech_key" => speech_key,
+         "duration" => duration,
+         "cue_count" => length(cues),
+         "scene_count" => length(scenes),
+         "speech_seconds" =>
+           speech |> Enum.reduce(0.0, &(&2 + &1.end - &1.start)) |> Float.round(1)
+       }, []}
+    else
+      {:error, :no_descriptions} ->
+        {:ok, AD.skipped(@step_type, ctx, "no_descriptions"), []}
+
+      {:error, reason} ->
+        AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp describe_batches(ctx, stills, scenes, speech, duration) do
+    stills
+    |> Enum.map(&%{scene: &1["scene"], time: &1["time"] * 1.0, key: &1["key"]})
+    |> Timeline.batch_stills(@max_images)
+    |> Enum.reduce_while({:ok, []}, fn batch, {:ok, cues} ->
+      case describe_batch(ctx, batch, cues, scenes, speech, duration) do
+        {:ok, batch_cues} -> {:cont, {:ok, cues ++ batch_cues}}
+        {:error, reason} -> {:halt, {:error, reason}}
+      end
+    end)
+  end
+
+  defp describe_batch(ctx, batch, previous_cues, scenes, speech, duration) do
+    window = %{
+      start: scene_bound(scenes, hd(batch).scene, :start, 0.0),
+      end: scene_bound(scenes, List.last(batch).scene, :end, duration)
+    }
+
+    timing = Timeline.timing_prompt(speech, scenes, duration, window)
+    previous = previous_cues |> Enum.take(-3) |> Enum.map(&to_string(&1["text"]))
+
+    with {:ok, images} <- load_stills(ctx, batch) do
+      content =
+        images ++ [%{"type" => "text", "text" => Prompts.stills_request(window, previous)}]
+
+      case AD.chat_provider().chat_json(
+             Prompts.describe_instruction(duration, timing, AD.language(ctx)),
+             content,
+             schema: Prompts.cues_schema(),
+             max_tokens: 8_000
+           ) do
+        {:ok, %{"cues" => cues}} when is_list(cues) -> {:ok, Enum.filter(cues, &is_map/1)}
+        {:ok, _answer} -> {:ok, []}
+        {:error, reason} -> {:error, reason}
+      end
+    end
+  end
+
+  defp load_stills(ctx, batch) do
+    Enum.reduce_while(batch, {:ok, []}, fn still, {:ok, parts} ->
+      case ctx.storage.get(ctx.bucket, still.key, ctx.region) do
+        {:ok, image} ->
+          label = "S#{still.scene} at #{:erlang.float_to_binary(still.time, decimals: 2)} s:"
+
+          {:cont,
+           {:ok,
+            parts ++
+              [
+                %{"type" => "text", "text" => label},
+                %{
+                  "type" => "image_url",
+                  "image_url" => %{"url" => "data:image/jpeg;base64," <> Base.encode64(image)}
+                }
+              ]}}
+
+        {:error, reason} ->
+          {:halt, {:error, {:still_unavailable, still.key, reason}}}
+      end
+    end)
+  end
+
+  # Pin cues to their scene and chosen pause, using the same scenes and pauses the model was given.
+  defp clean_cues(raw_cues, speech, scenes, duration) do
+    gaps = Timeline.free_gaps(speech, duration)
+
+    raw_cues
+    |> Enum.flat_map(fn cue ->
+      start = Cues.parse_timestamp(cue["start"])
+      text = cue["text"]
+
+      if is_nil(start) or not is_binary(text) do
+        []
+      else
+        [
+          %{
+            start: start,
+            end: Cues.parse_timestamp(cue["end"]) || start + 2,
+            text: text,
+            pause: integer_or_nil(cue["pause"]),
+            scene: integer_or_nil(cue["shot"])
+          }
+        ]
+      end
+    end)
+    |> Timeline.snap_cues(gaps, scenes)
+    |> Cues.normalize(duration)
+  end
+
+  defp require_cues([]), do: {:error, :no_descriptions}
+  defp require_cues(_cues), do: :ok
+
+  defp speech(ctx, duration) do
+    case Map.get(ctx.outputs, "transcribe_audio") do
+      %{"status" => "ok", "subtitle_json_key" => key} when is_binary(key) ->
+        with {:ok, %{"segments" => segments}} <- AD.get_json(ctx, key) do
+          {:ok, speech_from_segments(segments, duration)}
+        end
+
+      _ ->
+        transcribe(ctx, duration)
+    end
+  end
+
+  # Without a transcription from the flow, measure the speech here. A video without
+  # audio has no speech, so every moment is a pause.
+  defp transcribe(ctx, duration) do
+    case Map.get(ctx.outputs, "transcode_audio") do
+      %{"status" => "ok", "key" => key} when is_binary(key) ->
+        provider =
+          Application.get_env(:mave_core, :transcription_provider, MaveCore.Transcription.Mistral)
+
+        with {:ok, transcription} <- transcribe_with(provider, ctx, key) do
+          {:ok, speech_from_segments(Map.get(transcription, :segments, []), duration)}
+        end
+
+      _ ->
+        {:ok, []}
+    end
+  end
+
+  defp transcribe_with(provider, ctx, key) do
+    opts = [filename: Path.basename(key), content_type: "audio/mpeg"]
+    url = SettingsSerializer.storage_object_url(ctx.bucket, key)
+
+    url_result =
+      if is_binary(url) and function_exported?(provider, :transcribe_url, 2),
+        do: provider.transcribe_url(url, opts),
+        else: {:error, :url_unsupported}
+
+    case url_result do
+      {:ok, transcription} ->
+        {:ok, transcription}
+
+      {:error, _reason} ->
+        with {:ok, body} <- ctx.storage.get(ctx.bucket, key, ctx.region) do
+          provider.transcribe(body, opts)
+        end
+    end
+  end
+
+  defp speech_from_segments(segments, duration) when is_list(segments) do
+    segments
+    |> Enum.flat_map(fn segment ->
+      start = number(segment[:start] || segment["start"])
+      stop = number(segment[:end] || segment["end"])
+      if start && stop, do: [%{start: start, end: stop}], else: []
+    end)
+    |> Timeline.speech_from_words(duration)
+  end
+
+  defp speech_from_segments(_segments, _duration), do: []
+
+  defp scene_bound(scenes, index, key, default) do
+    case Enum.at(scenes, index || 0) do
+      %{} = scene -> Map.fetch!(scene, key)
+      nil -> default
+    end
+  end
+
+  defp intervals(list) when is_list(list) do
+    Enum.map(list, &%{start: &1["start"] * 1.0, end: &1["end"] * 1.0})
+  end
+
+  defp intervals(_list), do: []
+
+  defp interval_json(%{start: start, end: stop}), do: %{"start" => start, "end" => stop}
+
+  defp integer_or_nil(value) when is_integer(value), do: value
+  defp integer_or_nil(value) when is_float(value), do: trunc(value)
+  defp integer_or_nil(_value), do: nil
+
+  defp number(value) when is_number(value), do: value * 1.0
+  defp number(_value), do: nil
+end
diff --git a/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
new file mode 100644
index 0000000..fed75b5
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_speak_descriptions_step.ex
@@ -0,0 +1,99 @@
+defmodule MaveCore.Flow.Steps.AiSpeakDescriptionsStep do
+  @moduledoc """
+  Speaks every description cue of one language with text-to-speech, in a voice
+  of that language. Clips are stored privately as trimmed mono 24 kHz PCM; a
+  clip that already exists is reused, so a retry only speaks what is missing.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription.{Cues, Wav}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.speak_descriptions"
+  @concurrency 5
+  @timeout_ms 3 * 60 * 1000
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+    source_step_id = AD.source_step_id(ctx, "describe_video")
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, source} <- AD.check_dependency(ctx, source_step_id) do
+      speak(ctx, source, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp speak(ctx, source, language) do
+    with {:ok, json} <- AD.get_json(ctx, source["cues_key"]),
+         cues = Cues.from_json(json),
+         {:ok, clips} <- speak_cues(ctx, cues, language) do
+      {:ok,
+       source
+       |> Map.take(["speech_key", "duration", "cues_key"])
+       |> Map.merge(%{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "sample_rate" => Wav.sample_rate(),
+         "clips" => clips
+       }), []}
+    else
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp speak_cues(ctx, cues, language) do
+    cues
+    |> Enum.with_index()
+    |> Task.async_stream(fn {cue, index} -> speak_cue(ctx, cue, index, language) end,
+      max_concurrency: @concurrency,
+      timeout: @timeout_ms,
+      ordered: true
+    )
+    |> Enum.reduce_while({:ok, []}, fn
+      {:ok, {:ok, clip}}, {:ok, clips} -> {:cont, {:ok, [clip | clips]}}
+      {:ok, {:error, reason}}, _acc -> {:halt, {:error, reason}}
+      {:exit, reason}, _acc -> {:halt, {:error, {:speech_task_exit, reason}}}
+    end)
+    |> case do
+      {:ok, clips} -> {:ok, Enum.reverse(clips)}
+      error -> error
+    end
+  end
+
+  defp speak_cue(ctx, cue, index, language) do
+    # Retrying a description run can change its text or voice at the same index.
+    # Reuse a clip only while all inputs to speech generation stay the same.
+    fingerprint =
+      {cue.text, language, AD.speech_provider(),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_TTS_MODEL"),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_VOICES"),
+       System.get_env("MAVE_AUDIO_DESCRIPTION_VOICE")}
+      |> :erlang.term_to_binary()
+      |> then(&:crypto.hash(:sha256, &1))
+      |> Base.encode16(case: :lower)
+
+    key =
+      AD.work_key(
+        ctx,
+        "#{language}/speech/#{String.pad_leading("#{index}", 5, "0")}-#{fingerprint}.pcm"
+      )
+
+    case ctx.storage.get(ctx.bucket, key, ctx.region) do
+      {:ok, pcm} ->
+        {:ok, %{"key" => key, "samples" => div(byte_size(pcm), 2)}}
+
+      {:error, _not_found} ->
+        with {:ok, audio} <- AD.speech_provider().speak(cue.text, language),
+             {:ok, pcm} <- Wav.clip(audio),
+             {:ok, _} <- AD.put_private(ctx, key, pcm, "application/octet-stream") do
+          {:ok, %{"key" => key, "samples" => div(byte_size(pcm), 2)}}
+        end
+    end
+  end
+end
diff --git a/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex b/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex
new file mode 100644
index 0000000..9e12f86
--- /dev/null
+++ b/lib/mave_core/flow/steps/ai_translate_descriptions_step.ex
@@ -0,0 +1,57 @@
+defmodule MaveCore.Flow.Steps.AiTranslateDescriptionsStep do
+  @moduledoc """
+  Translates the English description cues into `params["language"]`. Timings stay
+  the same; each translation has to fit the time slot of its cue.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription.{Cues, Prompts}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+
+  @step_type "ai.translate_descriptions"
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, source} <- AD.check_dependency(ctx, AD.source_step_id(ctx, "describe_video")) do
+      translate(ctx, source, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp translate(ctx, source, language) do
+    with {:ok, json} <- AD.get_json(ctx, source["cues_key"]),
+         cues = Cues.from_json(json),
+         {instruction, input} = Prompts.translation_request(cues, language),
+         {:ok, answer} <-
+           AD.chat_provider().chat_json(
+             instruction,
+             [%{"type" => "text", "text" => Jason.encode!(input)}],
+             schema: Prompts.translations_schema(),
+             max_tokens: 16_000
+           ),
+         {:ok, texts} <- Prompts.check_translations(answer["translations"], length(cues)),
+         translated =
+           cues |> Enum.zip(texts) |> Enum.map(fn {cue, text} -> %{cue | text: text} end),
+         {:ok, cues_key} <-
+           AD.put_json(ctx, AD.work_key(ctx, "#{language}/cues.json"), Cues.to_json(translated)) do
+      {:ok,
+       source
+       |> Map.take(["speech_key", "duration"])
+       |> Map.merge(%{
+         "status" => "ok",
+         "step_type" => @step_type,
+         "step_id" => ctx.step_id,
+         "language" => language,
+         "cues_key" => cues_key,
+         "cue_count" => length(translated)
+       }), []}
+    else
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+end
diff --git a/lib/mave_core/flow/steps/audio_description_support.ex b/lib/mave_core/flow/steps/audio_description_support.ex
new file mode 100644
index 0000000..2aa5515
--- /dev/null
+++ b/lib/mave_core/flow/steps/audio_description_support.ex
@@ -0,0 +1,196 @@
+defmodule MaveCore.Flow.Steps.AudioDescriptionSupport do
+  @moduledoc """
+  Shared plumbing of the audio-description flow steps: run coordinates, private
+  working objects and the result shapes.
+
+  Every step skips itself when the run didn't ask for audio descriptions, so the
+  steps cost nothing in the publishing presets for other spaces. Transient
+  provider and storage errors are returned as errors (the flow engine retries
+  them); anything else makes the step `unavailable`, which never blocks
+  publication.
+  """
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.Flow.RetryPolicy
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+  alias MaveCore.Media.Storage
+
+  @failure_tags %{
+    "media.detect_scenes" => :media_detect_scenes_failed,
+    "ai.describe_video" => :ai_describe_video_failed,
+    "ai.translate_descriptions" => :ai_translate_descriptions_failed,
+    "ai.speak_descriptions" => :ai_speak_descriptions_failed,
+    "media.mix_audio_description" => :media_mix_audio_description_failed
+  }
+
+  def run_context(step, context) do
+    run_input = Map.get(context, :run_input, %{})
+    outputs = Map.get(context, :dependency_outputs, %{})
+    source = Map.get(outputs, "source", %{})
+    params = Map.get(step, "params", %{})
+    space_hash = source["space_hash"] || run_input["space_hash"]
+    region = run_input["region"]
+
+    %{
+      step_id: Map.get(step, "id"),
+      params: params,
+      run_input: run_input,
+      outputs: outputs,
+      space_hash: space_hash,
+      embed_hash: source["embed_hash"] || run_input["embed_hash"],
+      version: StepSupport.normalize_version(source["version"] || run_input["version"]),
+      region: region,
+      bucket: Storage.bucket_for_space(space_hash, region),
+      storage: Application.get_env(:mave_core, :flow_storage_adapter, Storage),
+      languages: AudioDescription.requested_languages(run_input),
+      strict?: StepSupport.strict_enabled?(params, run_input, "audio_description_strict")
+    }
+  end
+
+  @doc "`:ok`, or the reason the step has nothing to do."
+  def check_requested(%{languages: []}), do: {:skip, "not_requested"}
+
+  def check_requested(%{params: %{"language" => language}, languages: languages}) do
+    if language in languages, do: :ok, else: {:skip, "language_not_requested"}
+  end
+
+  def check_requested(_ctx), do: :ok
+
+  @doc "The status of a dependency step that must have succeeded."
+  def check_dependency(ctx, step_id) do
+    case Map.get(ctx.outputs, step_id) do
+      %{"status" => "ok"} = output ->
+        {:ok, output}
+
+      %{"status" => status, "reason" => reason} when status in ["skipped", "unavailable"] ->
+        {:skip, reason}
+
+      %{"status" => status} when status in ["skipped", "unavailable"] ->
+        {:skip, "#{step_id}_#{status}"}
+
+      _ ->
+        {:skip, "#{step_id}_missing"}
+    end
+  end
+
+  @doc "The dependency named by `params[\"source_step_id\"]`."
+  def source_step_id(ctx, default), do: Map.get(ctx.params, "source_step_id", default)
+
+  def language(ctx) do
+    case Map.get(ctx.params, "language") do
+      "original" ->
+        get_in(ctx.outputs, [source_step_id(ctx, "describe_video"), "language"]) ||
+          AudioDescription.original_language(
+            ctx.run_input,
+            ctx.outputs,
+            ctx.params["fallback_language"]
+          )
+
+      nil ->
+        if "original" in ctx.languages,
+          do:
+            AudioDescription.original_language(
+              ctx.run_input,
+              ctx.outputs,
+              ctx.params["fallback_language"]
+            ),
+          else: AudioDescription.source_language()
+
+      language ->
+        language
+    end
+  end
+
+  def work_key(ctx, name),
+    do: "#{AudioDescription.work_prefix(ctx.embed_hash, ctx.version)}/#{name}"
+
+  def output_key(ctx, filename),
+    do: "#{AudioDescription.version_prefix(ctx.embed_hash, ctx.version)}/#{filename}"
+
+  @doc "Stores a private JSON working object."
+  def put_json(ctx, key, value) do
+    body = Jason.encode!(value)
+
+    case ctx.storage.put(ctx.bucket, key, body, "application/json", ctx.region) do
+      {:ok, _} -> {:ok, key}
+      {:error, reason} -> {:error, {:storage_put_failed, key, reason}}
+    end
+  end
+
+  def get_json(ctx, key) when is_binary(key) do
+    with {:ok, body} <- ctx.storage.get(ctx.bucket, key, ctx.region),
+         {:ok, value} <- decode_json(body) do
+      {:ok, value}
+    else
+      {:error, %Jason.DecodeError{}} -> {:error, {:invalid_json, key}}
+      {:error, reason} -> {:error, {:storage_get_failed, key, reason}}
+    end
+  end
+
+  def get_json(_ctx, key), do: {:error, {:missing_key, key}}
+
+  # HTTP storage adapters may already decode application/json responses.
+  defp decode_json(body) when is_map(body) or is_list(body), do: {:ok, body}
+  defp decode_json(body), do: Jason.decode(body)
+
+  def put_private(ctx, key, body, content_type) do
+    case ctx.storage.put(ctx.bucket, key, body, content_type, ctx.region) do
+      {:ok, _} -> {:ok, key}
+      {:error, reason} -> {:error, {:storage_put_failed, key, reason}}
+    end
+  end
+
+  def chat_provider do
+    AudioDescription.config(:chat_provider, MaveCore.AudioDescription.Scaleway)
+  end
+
+  def speech_provider do
+    AudioDescription.config(:speech_provider, MaveCore.AudioDescription.MistralSpeech)
+  end
+
+  def skipped(step_type, ctx, reason, extra \\ %{}) do
+    Map.merge(
+      %{
+        "status" => "skipped",
+        "step_type" => step_type,
+        "step_id" => ctx.step_id,
+        "reason" => reason
+      },
+      extra
+    )
+  end
+
+  @doc "The step result for a failure: retried when transient, otherwise `unavailable`."
+  def failure(step_type, ctx, reason) do
+    if ctx.strict? or RetryPolicy.transient_error?(reason) do
+      {:error, {Map.fetch!(@failure_tags, step_type), reason}}
+    else
+      {:ok,
+       %{
+         "status" => "unavailable",
+         "step_type" => step_type,
+         "step_id" => ctx.step_id,
+         "error" => inspect(reason)
+       }, []}
+    end
+  end
+
+  def artifact(name, ctx, key, media_type, size, metadata \\ %{}) do
+    %{
+      name: name,
+      uri: "s3://#{ctx.bucket}/#{key}",
+      media_type: media_type,
+      size_bytes: size,
+      metadata:
+        Map.merge(
+          %{
+            "type" => "audio_description",
+            "space_hash" => ctx.space_hash,
+            "embed_hash" => ctx.embed_hash,
+            "version" => ctx.version
+          },
+          metadata
+        )
+    }
+  end
+end
diff --git a/lib/mave_core/flow/steps/media_build_hls_master_step.ex b/lib/mave_core/flow/steps/media_build_hls_master_step.ex
index b3ee77b..2ed39ae 100644
--- a/lib/mave_core/flow/steps/media_build_hls_master_step.ex
+++ b/lib/mave_core/flow/steps/media_build_hls_master_step.ex
@@ -220,6 +220,21 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
           |> Enum.filter(&is_map/1)
           |> Enum.map(&normalize_audio_track_map/1)
 
+        # Audio descriptions: full mixes marked for assistive technology, never the default.
+        %{
+          "step_type" => "media.mix_audio_description",
+          "status" => "ok",
+          "audio_tracks" => tracks
+        }
+        when is_list(tracks) ->
+          tracks
+          |> Enum.filter(&is_map/1)
+          |> Enum.map(&normalize_audio_track_map/1)
+
+        %{"step_type" => "media.mix_audio_description", "status" => "ok", "audio_track" => track}
+        when is_map(track) ->
+          [normalize_audio_track_map(track)]
+
         _ ->
           []
       end
@@ -324,7 +339,8 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
       "channels" => normalize_string(first_map_value(track, ["hls_channels", "channels"], "2")),
       "bandwidth" => normalize_integer(first_map_value(track, ["hls_bandwidth", "bandwidth"])),
       "playlist_path" => first_map_value(track, ["hls_playlist", "playlist_path"]),
-      "playlist_uri" => first_map_value(track, ["hls_src", "playlist_uri"])
+      "playlist_uri" => first_map_value(track, ["hls_src", "playlist_uri"]),
+      "characteristics" => first_map_value(track, ["characteristics"])
     }
   end
 
@@ -546,8 +562,11 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
 
   defp audio_media_line(track, group_id) do
     default? = track["default"] in [true, "true", 1, "1"]
+    characteristics = track["characteristics"]
     default_flag = if default?, do: "YES", else: "NO"
-    autoselect_flag = if default?, do: "YES", else: "NO"
+    # Players select an accessibility track by its characteristics when the viewer asks
+    # for audio description, which requires AUTOSELECT=YES.
+    autoselect_flag = if default? or is_binary(characteristics), do: "YES", else: "NO"
 
     attrs =
       [
@@ -556,10 +575,13 @@ defmodule MaveCore.Flow.Steps.MediaBuildHlsMasterStep do
         ~s(NAME="#{escape_attr(track["name"] || "Audio")}"),
         ~s(LANGUAGE="#{escape_attr(track["language"] || "und")}"),
         "DEFAULT=#{default_flag}",
-        "AUTOSELECT=#{autoselect_flag}",
+        "AUTOSELECT=#{autoselect_flag}"
+      ]
+      |> append_quoted_attr("CHARACTERISTICS", characteristics)
+      |> Kernel.++([
         ~s(CHANNELS="#{escape_attr(track["channels"] || "2")}"),
         ~s(URI="#{escape_attr(track["playlist_path"] || "")}")
-      ]
+      ])
       |> append_attr("BANDWIDTH", track["bandwidth"])
 
     "#EXT-X-MEDIA:#{Enum.join(attrs, ",")}"
diff --git a/lib/mave_core/flow/steps/media_detect_scenes_step.ex b/lib/mave_core/flow/steps/media_detect_scenes_step.ex
new file mode 100644
index 0000000..f119235
--- /dev/null
+++ b/lib/mave_core/flow/steps/media_detect_scenes_step.ex
@@ -0,0 +1,206 @@
+defmodule MaveCore.Flow.Steps.MediaDetectScenesStep do
+  @moduledoc """
+  Detects camera cuts with FFmpeg (`scdet`), groups them into scenes of at least
+  3 s and extracts labelled 360p stills (one per ~3 s per shot) for the
+  description model. One decode of the canonical source does both.
+
+  Stores the private `audio_description/scenes.json` and `audio_description/stills/*`.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.AudioDescription.Timeline
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+
+  @step_type "media.detect_scenes"
+  # Cuts closer together than this (or to the start) are detection noise.
+  @min_shot_seconds 0.5
+  @scdet_threshold 10
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    duration_ms = StepSupport.inspect_duration_ms(ctx.outputs)
+
+    cond do
+      AD.check_requested(ctx) != :ok ->
+        {:skip, reason} = AD.check_requested(ctx)
+        {:ok, AD.skipped(@step_type, ctx, reason), []}
+
+      StepSupport.inspect_reports_no_video?(ctx.outputs) ->
+        {:ok, AD.skipped(@step_type, ctx, "no_video"), []}
+
+      not (is_number(duration_ms) and duration_ms > 0) ->
+        {:ok, AD.skipped(@step_type, ctx, "unknown_duration"), []}
+
+      duration_ms / 1000 > AudioDescription.max_seconds() ->
+        {:ok,
+         AD.skipped(@step_type, ctx, "video_too_long", %{
+           "video_duration_seconds" => Float.round(duration_ms / 1000, 3),
+           "max_duration_seconds" => AudioDescription.max_seconds()
+         }), []}
+
+      true ->
+        detect(ctx, context, duration_ms / 1000)
+    end
+  end
+
+  defp detect(ctx, context, duration) do
+    source = Map.get(ctx.outputs, "source", %{})
+    source_url = source["source_url"] || ctx.run_input["input_url"] || ctx.run_input["source_url"]
+    fps = if duration > 180, do: 1, else: 2
+
+    progress =
+      StepSupport.ffmpeg_progress(context[:progress_reporter], %{
+        stage: "detect_scenes",
+        step_id: ctx.step_id,
+        total_ms: round(duration * 1000)
+      })
+
+    result =
+      StepSupport.with_temp_dir("detect_scenes", fn dir ->
+        with {:ok, scd_path} <- StepSupport.tmp_file_path(dir, "scd", "txt"),
+             {:ok, null_path} <- StepSupport.tmp_file_path(dir, "cuts", "null"),
+             {:ok, frames_dir} <- StepSupport.tmp_file_path(dir, "frames"),
+             :ok <- StepSupport.mkdir_tmp_dir(frames_dir),
+             {:ok, _, _} <-
+               StepSupport.run_ffmpeg_with_storage_fallback(
+                 dir,
+                 ctx.run_input,
+                 source_url,
+                 ctx.outputs,
+                 &{:ok, ffmpeg_args(&1, scd_path, null_path, frames_dir, fps)},
+                 progress: progress
+               ),
+             {:ok, scd} <- StepSupport.read_tmp_file(scd_path) do
+          cuts = parse_cuts(scd)
+          shots = Timeline.shots_from_cuts(cuts, duration)
+          scenes = Timeline.scenes_from_shots(shots)
+          stills = Timeline.plan_stills(scenes, duration, 3, shots)
+          store(ctx, frames_dir, fps, duration, cuts, shots, scenes, stills)
+        end
+      end)
+
+    case result do
+      {:ok, output, artifacts} -> {:ok, output, artifacts}
+      {:error, reason} -> AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp store(ctx, frames_dir, fps, duration, cuts, shots, scenes, stills) do
+    stills
+    |> Enum.with_index()
+    |> Enum.reduce_while({:ok, []}, fn {still, index}, {:ok, acc} ->
+      key = AD.work_key(ctx, "stills/#{pad(index)}.jpg")
+
+      with {:ok, image} <- read_frame(frames_dir, round(still.time * fps) + 1),
+           {:ok, _} <- AD.put_private(ctx, key, image, "image/jpeg") do
+        {:cont, {:ok, [Map.put(still, :key, key) | acc]}}
+      else
+        {:error, reason} -> {:halt, {:error, reason}}
+      end
+    end)
+    |> case do
+      {:ok, stored} ->
+        scenes_key = AD.work_key(ctx, "scenes.json")
+
+        document = %{
+          "duration" => duration,
+          "cuts" => cuts,
+          "shots" => Enum.map(shots, &interval_json/1),
+          "scenes" => Enum.map(scenes, &interval_json/1),
+          "stills" =>
+            stored
+            |> Enum.reverse()
+            |> Enum.map(&%{"scene" => &1.scene, "time" => &1.time, "key" => &1.key})
+        }
+
+        with {:ok, _} <- AD.put_json(ctx, scenes_key, document) do
+          {:ok,
+           %{
+             "status" => "ok",
+             "step_type" => @step_type,
+             "step_id" => ctx.step_id,
+             "scenes_key" => scenes_key,
+             "duration" => duration,
+             "cut_count" => length(cuts),
+             "scene_count" => length(scenes),
+             "still_count" => length(stored)
+           }, []}
+        end
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  # The fps filter emits frame n (1-based) at (n - 1) / fps; a still near the very end
+  # may round past the last frame.
+  defp read_frame(frames_dir, number) when number >= 1 do
+    with {:ok, path} <- StepSupport.tmp_file_path(frames_dir, pad(number), "jpg") do
+      case StepSupport.read_tmp_file(path) do
+        {:ok, image} -> {:ok, image}
+        {:error, _reason} when number > 1 -> read_frame(frames_dir, number - 1)
+        {:error, reason} -> {:error, {:missing_still, reason}}
+      end
+    end
+  end
+
+  defp ffmpeg_args(source, scd_path, null_path, frames_dir, fps) do
+    filter =
+      "[0:v]split=2[a][b];" <>
+        "[a]scale=320:-2,scdet=threshold=#{@scdet_threshold}," <>
+        "metadata=print:key=lavfi.scd.time:file='#{escape_filter_path(scd_path)}'[cuts];" <>
+        "[b]fps=#{fps},scale=-2:360[stills]"
+
+    [
+      "-y",
+      "-v",
+      "error",
+      "-i",
+      source,
+      "-an",
+      "-sn",
+      "-filter_complex",
+      filter,
+      "-map",
+      "[cuts]",
+      "-f",
+      "null",
+      # Keep an explicit output path so the sandbox grants this job's directory.
+      null_path,
+      "-map",
+      "[stills]",
+      "-q:v",
+      "5",
+      Path.join(frames_dir, "%05d.jpg")
+    ]
+  end
+
+  @doc false
+  def parse_cuts(body) do
+    ~r/lavfi\.scd\.time=([0-9.]+)/
+    |> Regex.scan(body, capture: :all_but_first)
+    |> Enum.flat_map(fn [value] ->
+      case Float.parse(value) do
+        {time, _} -> [time]
+        :error -> []
+      end
+    end)
+    |> Enum.sort()
+    |> Enum.reduce([], fn time, kept ->
+      previous = List.first(kept) || 0.0
+      if time - previous >= @min_shot_seconds, do: [time | kept], else: kept
+    end)
+    |> Enum.reverse()
+    |> Enum.map(&Timeline.round3/1)
+  end
+
+  defp interval_json(%{start: start, end: stop}), do: %{"start" => start, "end" => stop}
+
+  defp pad(number), do: number |> Integer.to_string() |> String.pad_leading(5, "0")
+
+  defp escape_filter_path(path),
+    do: path |> String.replace("\\", "\\\\") |> String.replace("'", "'\\''")
+end
diff --git a/lib/mave_core/flow/steps/media_mix_audio_description_step.ex b/lib/mave_core/flow/steps/media_mix_audio_description_step.ex
new file mode 100644
index 0000000..c17a0db
--- /dev/null
+++ b/lib/mave_core/flow/steps/media_mix_audio_description_step.ex
@@ -0,0 +1,256 @@
+defmodule MaveCore.Flow.Steps.MediaMixAudioDescriptionStep do
+  @moduledoc """
+  Builds the audio description of one language: places the spoken clips on the
+  timeline (in a pause, or over speech with the original ducked to 20%), mixes
+  them with the video's own audio into `audio_description_<lang>.mp3`, writes
+  `descriptions_<lang>.vtt` timed to when each description is spoken, and
+  packages the MP3 as an HLS audio rendition marked
+  `public.accessibility.describes-video`.
+  """
+  @behaviour MaveCore.Flow.Step
+
+  alias MaveCore.AudioDescription
+  alias MaveCore.AudioDescription.{Cues, Mix, Timeline, Wav}
+  alias MaveCore.Flow.Steps.AudioDescriptionSupport, as: AD
+  alias MaveCore.Flow.Steps.MediaPackageHlsAudioStep
+  alias MaveCore.Flow.Steps.Support, as: StepSupport
+  alias MaveCore.Languages
+
+  @step_type "media.mix_audio_description"
+  @characteristics "public.accessibility.describes-video"
+
+  def characteristics, do: @characteristics
+
+  @impl true
+  def run(step, context) do
+    ctx = AD.run_context(step, context)
+    language = AD.language(ctx)
+
+    with :ok <- AD.check_requested(ctx),
+         {:ok, speech} <-
+           AD.check_dependency(ctx, AD.source_step_id(ctx, "speak_descriptions_#{language}")) do
+      mix(ctx, context, speech, language)
+    else
+      {:skip, reason} -> {:ok, AD.skipped(@step_type, ctx, reason, %{"language" => language}), []}
+    end
+  end
+
+  defp mix(ctx, context, speech_output, language) do
+    duration = speech_output["duration"] * 1.0
+
+    with {:ok, cues_json} <- AD.get_json(ctx, speech_output["cues_key"]),
+         {:ok, speech_json} <- AD.get_json(ctx, speech_output["speech_key"]),
+         {:ok, clips} <- load_clips(ctx, speech_output["clips"]),
+         cues = Cues.from_json(cues_json),
+         speech = Enum.map(speech_json, &%{start: &1["start"] * 1.0, end: &1["end"] * 1.0}),
+         lengths = Enum.map(clips, &div(byte_size(&1), 2)),
+         timeline = Timeline.plan_timeline(cues, lengths, speech, duration, Wav.sample_rate()),
+         :ok <- require_placements(timeline),
+         {:ok, audio_size} <- render_and_mix(ctx, context, timeline, clips, duration, language),
+         vtt = Cues.to_vtt(timeline.cues, language),
+         vtt_key = AD.output_key(ctx, AudioDescription.vtt_filename(language)),
+         {:ok, _} <- ctx.storage.put_public(ctx.bucket, vtt_key, vtt, "text/vtt", ctx.region),
+         {:ok, hls} <- package_hls(ctx, language, audio_size) do
+      output(ctx, language, timeline, audio_size, byte_size(vtt), hls)
+    else
+      {:error, :no_placements} ->
+        {:ok, AD.skipped(@step_type, ctx, "no_descriptions", %{"language" => language}), []}
+
+      {:error, reason} ->
+        AD.failure(@step_type, ctx, reason)
+    end
+  end
+
+  defp load_clips(ctx, clips) when is_list(clips) do
+    Enum.reduce_while(clips, {:ok, []}, fn %{"key" => key}, {:ok, acc} ->
+      case ctx.storage.get(ctx.bucket, key, ctx.region) do
+        {:ok, pcm} -> {:cont, {:ok, [pcm | acc]}}
+        {:error, reason} -> {:halt, {:error, {:speech_clip_unavailable, key, reason}}}
+      end
+    end)
+    |> case do
+      {:ok, loaded} -> {:ok, Enum.reverse(loaded)}
+      error -> error
+    end
+  end
+
+  defp load_clips(_ctx, _clips), do: {:error, :missing_speech_clips}
+
+  defp require_placements(%{placements: []}), do: {:error, :no_placements}
+  defp require_placements(_timeline), do: :ok
+
+  defp render_and_mix(ctx, context, timeline, clips, duration, language) do
+    clips = List.to_tuple(clips)
+    audio_key = AD.output_key(ctx, AudioDescription.audio_filename(language))
+
+    progress =
+      StepSupport.ffmpeg_progress(context[:progress_reporter], %{
+        stage: "mix_audio_description",
+        step_id: ctx.step_id,
+        total_ms: round(duration * 1000)
+      })
+
+    StepSupport.with_temp_dir("audio_description", fn dir ->
+      with {:ok, description_path} <- StepSupport.tmp_file_path(dir, "description", "pcm"),
+           {:ok, output_path} <- StepSupport.tmp_file_path(dir, "mix", "mp3"),
+           pcm = Wav.render(timeline.placements, timeline.total_samples, &elem(clips, &1)),
+           :ok <- StepSupport.write_tmp_file(description_path, pcm),
+           build = &Mix.ffmpeg_args(&1, description_path, output_path, timeline.ducks, duration),
+           :ok <- run_mix(ctx, dir, build, progress),
+           {:ok, %{size: size}} <- MaveCore.SafeFile.stat_regular(output_path),
+           {:ok, _} <-
+             ctx.storage.put_file_public(
+               ctx.bucket,
+               audio_key,
+               output_path,
+               "audio/mpeg",
+               ctx.region
+             ) do
+        {:ok, size}
+      end
+    end)
+  end
+
+  # Mix with the video's own audio, or the descriptions alone when the video has none.
+  defp run_mix(ctx, dir, build, progress) do
+    case Map.get(ctx.outputs, "transcode_audio") do
+      %{"status" => "ok", "key" => key} when is_binary(key) ->
+        case StepSupport.run_ffmpeg_with_storage_fallback(
+               dir,
+               ctx.run_input,
+               nil,
+               ctx.outputs,
+               &{:ok, build.(&1)},
+               progress: progress,
+               preferred_storage_step_id: "transcode_audio"
+             ) do
+          {:ok, _output, _fallback?} -> :ok
+          {:error, reason} -> {:error, reason}
+        end
+
+      _ ->
+        with {:ok, ffmpeg} <- StepSupport.find_ffmpeg(),
+             {_output, 0} <- StepSupport.run_media_cmd(ffmpeg, build.(nil)) do
+          :ok
+        else
+          {:error, reason} -> {:error, reason}
+          {output, status} -> {:error, {output, status}}
+        end
+    end
+  end
+
+  defp package_hls(ctx, language, audio_size) do
+    filename = AudioDescription.audio_filename(language)
+    key = AD.output_key(ctx, filename)
+    track = audio_track(ctx, language, filename, audio_size)
+
+    step = %{
+      "id" => "#{ctx.step_id}_hls",
+      "type" => "media.package_hls_audio",
+      "params" => %{"source_step_id" => "audio_description", "default" => false, "strict" => true}
+    }
+
+    context = %{
+      run_input: Map.take(ctx.run_input, ["space_hash", "embed_hash", "version", "region"]),
+      dependency_outputs: %{
+        "source" => Map.get(ctx.outputs, "source", %{}),
+        "audio_description" => %{
+          "step_type" => "media.transcode_audio",
+          "status" => "ok",
+          "bucket" => ctx.bucket,
+          "key" => key,
+          "uri" => "s3://#{ctx.bucket}/#{key}",
+          "audio_track" => track,
+          "audio_tracks" => [track]
+        }
+      }
+    }
+
+    case MediaPackageHlsAudioStep.run(step, context) do
+      {:ok, %{"status" => "ok", "audio_track" => packaged}, _artifacts} ->
+        {:ok, packaged}
+
+      {:ok, other, _artifacts} ->
+        {:error, {:hls_packaging_unavailable, other["error"] || other["reason"]}}
+
+      {:error, reason} ->
+        {:error, reason}
+    end
+  end
+
+  defp audio_track(ctx, language, filename, size) do
+    key = AD.output_key(ctx, filename)
+
+    %{
+      "id" => "audio_description_#{language}",
+      "label" => label(language),
+      "language" => language,
+      "default" => false,
+      "codec" => "mp3",
+      "file_size" => size,
+      "filename" => filename,
+      "bucket" => ctx.bucket,
+      "key" => key,
+      "path" => "s3://#{ctx.bucket}/#{key}",
+      "src" => "s3://#{ctx.bucket}/#{key}"
+    }
+  end
+
+  @doc "Name of the audio-description track of `language`, e.g. `English (audio description)`."
+  def label(language) do
+    "#{Languages.spoken_language(language) || String.upcase(language)} (audio description)"
+  end
+
+  defp output(ctx, language, timeline, audio_size, vtt_size, hls) do
+    audio_filename = AudioDescription.audio_filename(language)
+    vtt_filename = AudioDescription.vtt_filename(language)
+    audio_key = AD.output_key(ctx, audio_filename)
+    vtt_key = AD.output_key(ctx, vtt_filename)
+
+    description = %{
+      "language" => language,
+      "label" => label(language),
+      "audio_filename" => audio_filename,
+      "audio_file_size" => audio_size,
+      "vtt_filename" => vtt_filename,
+      "vtt_file_size" => vtt_size,
+      "cue_count" => length(timeline.cues),
+      "ducked_cue_count" => length(timeline.ducks),
+      "hls_playlist" => hls["hls_playlist"]
+    }
+
+    track =
+      hls
+      |> Map.take([
+        "id",
+        "label",
+        "language",
+        "hls_playlist",
+        "hls_src",
+        "hls_bandwidth",
+        "hls_channels"
+      ])
+      |> Map.merge(%{"default" => false, "characteristics" => @characteristics})
+
+    {:ok,
+     %{
+       "status" => "ok",
+       "step_type" => @step_type,
+       "step_id" => ctx.step_id,
+       "language" => language,
+       "audio_description" => description,
+       "audio_track" => track,
+       "cue_count" => length(timeline.cues),
+       "ducked_cue_count" => length(timeline.ducks),
+       "skipped_cue_count" => length(timeline.skipped)
+     },
+     [
+       AD.artifact("audio_description_#{language}", ctx, audio_key, "audio/mpeg", audio_size, %{
+         "language" => language
+       }),
+       AD.artifact("descriptions_#{language}", ctx, vtt_key, "text/vtt", vtt_size, %{
+         "language" => language
+       })
+     ]}
+  end
+end
diff --git a/lib/mave_core/public_api.ex b/lib/mave_core/public_api.ex
index adc4d17..8278de2 100644
--- a/lib/mave_core/public_api.ex
+++ b/lib/mave_core/public_api.ex
@@ -3,10 +3,12 @@ defmodule MaveCore.PublicApi do
 
   import Ecto.Query, warn: false
 
+  alias MaveCore.Assets
   alias MaveCore.Assets.{AudioTrack, Subtitle, Video}
+  alias MaveCore.AudioDescription
   alias MaveCore.Collections.CollectionEmbed
   alias MaveCore.Embeds
-  alias MaveCore.Embeds.{Embed, Events, SettingsSerializer}
+  alias MaveCore.Embeds.{Embed, Events, ManifestPublisher, SettingsSerializer}
   alias MaveCore.Flow
   alias MaveCore.Languages
   alias MaveCore.Playback.URLs
@@ -579,10 +581,31 @@ defmodule MaveCore.PublicApi do
         video_src: nil
       },
       subtitles: detailed_subtitles(space, embed, version),
-      audio_tracks: detailed_audio_tracks(space, embed, version)
+      audio_tracks: detailed_audio_tracks(space, embed, version),
+      audio_descriptions: detailed_audio_descriptions(space, current_video, embed, version)
     }
   end
 
+  defp detailed_audio_descriptions(_space, nil, _embed, _version), do: []
+
+  defp detailed_audio_descriptions(
+         %Space{} = space,
+         %Video{id: video_id},
+         %Embed{} = embed,
+         version
+       ) do
+    video_id
+    |> Assets.list_audio_descriptions()
+    |> Enum.map(
+      &ManifestPublisher.serialize_audio_description(
+        &1,
+        "space-#{space.hash}",
+        embed.hash,
+        version
+      )
+    )
+  end
+
   defp detailed_video_renditions(nil), do: nil
 
   defp detailed_video_renditions(%Video{id: video_id}) do
@@ -861,6 +884,12 @@ defmodule MaveCore.PublicApi do
       "durable_source_required" => true,
       "version" => current_video_version(embed)
     }
+    |> then(fn input ->
+      case AudioDescription.run_input(space) do
+        nil -> input
+        audio_description -> Map.put(input, "audio_description", audio_description)
+      end
+    end)
   end
 
   defp input_url_priority(%Space{} = space, params) do
diff --git a/lib/mave_core/spaces.ex b/lib/mave_core/spaces.ex
index d146ba5..4274136 100644
--- a/lib/mave_core/spaces.ex
+++ b/lib/mave_core/spaces.ex
@@ -627,25 +627,37 @@ defmodule MaveCore.Spaces do
     attrs =
       attrs
       |> stringify_keys()
-      |> Map.take(["hotlink_protection_enabled"])
+      |> Map.take(["hotlink_protection_enabled", "audio_description_enabled"])
 
-    space
-    |> Space.features_changeset(attrs)
-    |> Repo.update()
-    |> case do
-      {:ok, updated_space} ->
-        if Map.has_key?(attrs, "hotlink_protection_enabled") do
-          sync_domain_cors(updated_space.id)
-        end
-
-        Events.broadcast_updated(updated_space.id)
-        {:ok, updated_space}
+    with :ok <- authorize_feature_change(space, attrs),
+         {:ok, updated_space} <- space |> Space.features_changeset(attrs) |> Repo.update() do
+      if Map.has_key?(attrs, "hotlink_protection_enabled") do
+        sync_domain_cors(updated_space.id)
+      end
 
-      {:error, changeset} ->
-        {:error, changeset}
+      Events.broadcast_updated(updated_space.id)
+      {:ok, updated_space}
     end
   end
 
+  @doc """
+  Whether new uploads in the space get audio descriptions: the space opted in and
+  the host still allows it (a downgraded space stops getting them).
+  """
+  def audio_description_active?(%Space{audio_description_enabled: true} = space) do
+    UsageLimits.can_use_audio_description?(space) == :ok
+  end
+
+  def audio_description_active?(_space), do: false
+
+  # Turning audio descriptions off is always allowed; turning them on needs the host's consent.
+  defp authorize_feature_change(%Space{} = space, %{"audio_description_enabled" => value})
+       when value in [true, "true"] do
+    UsageLimits.can_use_audio_description?(space)
+  end
+
+  defp authorize_feature_change(_space, _attrs), do: :ok
+
   def update_space_processing(%Space{} = space, attrs) when is_map(attrs) do
     attrs =
       attrs
diff --git a/lib/mave_core/spaces/space.ex b/lib/mave_core/spaces/space.ex
index 6e169e9..1c4e4a8 100644
--- a/lib/mave_core/spaces/space.ex
+++ b/lib/mave_core/spaces/space.ex
@@ -11,6 +11,7 @@ defmodule MaveCore.Spaces.Space do
     field :region, :string
     field :public_sharing_enabled, :boolean
     field :hotlink_protection_enabled, :boolean
+    field :audio_description_enabled, :boolean, default: false
     field :default_flow_template, :string
     field :deleted_at, :utc_datetime_usec
 
@@ -36,7 +37,7 @@ defmodule MaveCore.Spaces.Space do
 
   def features_changeset(space, attrs) do
     space
-    |> cast(attrs, [:hotlink_protection_enabled])
+    |> cast(attrs, [:hotlink_protection_enabled, :audio_description_enabled])
     |> validate_shared_storage_features()
   end
 
diff --git a/lib/mave_core/uploads.ex b/lib/mave_core/uploads.ex
index 5906860..0d1ed5c 100644
--- a/lib/mave_core/uploads.ex
+++ b/lib/mave_core/uploads.ex
@@ -6,6 +6,7 @@ defmodule MaveCore.Uploads do
   require Logger
 
   alias MaveCore.Assets
+  alias MaveCore.AudioDescription
   alias MaveCore.EmbedId
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
@@ -332,10 +333,15 @@ defmodule MaveCore.Uploads do
   end
 
   defp handle_custom_audio_track(scope, bucket, key, metadata, upload) do
+    ingest =
+      if present(metadata, "audio_description") in ["true", "1", "yes"],
+        do: &Assets.ingest_uploaded_audio_description/4,
+        else: &Assets.ingest_uploaded_audio_track/4
+
     with {:ok, %Embed{space: %Space{hash: space_hash}, hash: embed_hash} = embed} <-
            upload_scope_existing_video(scope),
          {:ok, track} <-
-           Assets.ingest_uploaded_audio_track(
+           ingest.(
              embed,
              %{
                "audio_track_id" => present(metadata, "audio_track_id"),
@@ -365,10 +371,15 @@ defmodule MaveCore.Uploads do
   end
 
   defp handle_custom_subtitle(scope, bucket, key, metadata) do
+    ingest =
+      if present(metadata, "audio_description") in ["true", "1", "yes"],
+        do: &Assets.ingest_uploaded_audio_description_vtt/4,
+        else: &Assets.ingest_uploaded_subtitle/4
+
     with {:ok, %Embed{space: %Space{hash: space_hash}, hash: embed_hash} = embed} <-
            upload_scope_existing_video(scope),
          {:ok, subtitle} <-
-           Assets.ingest_uploaded_subtitle(
+           ingest.(
              embed,
              %{
                "subtitle_id" => present(metadata, "subtitle_id"),
@@ -714,7 +725,8 @@ defmodule MaveCore.Uploads do
         "callback_url" =>
           present(metadata, "callback_url") ||
             present(metadata, "webhook_url") ||
-            present(metadata, "notify_webhook_url")
+            present(metadata, "notify_webhook_url"),
+        "audio_description" => AudioDescription.run_input(space)
       }
       |> Enum.reject(fn {_key, value} -> is_nil(value) end)
       |> Map.new()
diff --git a/lib/mave_core/usage_limits.ex b/lib/mave_core/usage_limits.ex
index a9851ed..caa5b9f 100644
--- a/lib/mave_core/usage_limits.ex
+++ b/lib/mave_core/usage_limits.ex
@@ -10,9 +10,13 @@ defmodule MaveCore.UsageLimits do
   @callback can_add_space_member?(Space.t(), String.t() | atom()) :: :ok | {:error, term()}
   @callback can_view_space_data?(Space.t()) :: :ok | {:error, term()}
   @callback can_upload_file?(Space.t(), non_neg_integer() | nil) :: :ok | {:error, term()}
+  @callback can_use_audio_description?(Space.t()) :: :ok | {:error, term()}
   @callback restriction_copy(atom(), term()) :: %{optional(atom()) => String.t()}
 
-  @optional_callbacks can_view_space_data?: 1, can_upload_file?: 2, restriction_copy: 2
+  @optional_callbacks can_view_space_data?: 1,
+                      can_upload_file?: 2,
+                      can_use_audio_description?: 1,
+                      restriction_copy: 2
 
   def can_create_video_embed?(%Space{} = space) do
     dispatch(:can_create_video_embed?, [space])
@@ -26,6 +30,14 @@ defmodule MaveCore.UsageLimits do
     dispatch(:can_view_space_data?, [space])
   end
 
+  @doc """
+  Whether a space may generate audio descriptions. Allowed when the host has no
+  policy for it.
+  """
+  def can_use_audio_description?(%Space{} = space) do
+    dispatch(:can_use_audio_description?, [space])
+  end
+
   def can_upload_file?(%Space{} = space, size) when is_integer(size) or is_nil(size) do
     with :ok <- enforce_core_media_input_limit(size) do
       dispatch(:can_upload_file?, [space, size])
diff --git a/lib/mave_core_web/components/dashboard_components/settings.ex b/lib/mave_core_web/components/dashboard_components/settings.ex
index 6a3d4c7..72f3351 100644
--- a/lib/mave_core_web/components/dashboard_components/settings.ex
+++ b/lib/mave_core_web/components/dashboard_components/settings.ex
@@ -86,7 +86,7 @@ defmodule MaveCoreWeb.DashboardComponents.Settings do
     ~H"""
     <div
       class={[
-        "w-full h-8 px-2.5 border-y border-stone-800 font-semibold flex items-center text-xs uppercase text-stone-500",
+        "w-full h-8 px-3 border-y border-stone-800 font-semibold flex items-center text-xs uppercase text-stone-500",
         @disclosable && !@disabled && "cursor-pointer",
         !@disclosable && "cursor-default",
         @disabled && "opacity-50"
@@ -115,25 +115,31 @@ defmodule MaveCoreWeb.DashboardComponents.Settings do
 
       <div
         :if={@addable}
-        class="h-[1.125rem] w-[1.125rem] bg-stone-800 border-stone-900 mx-[0.1875rem] rounded-full flex items-center justify-center cursor-pointer hover:bg-stone-700"
-        {@rest}
+        data-settings-control="add"
+        class="h-6 w-6 flex-none flex items-center justify-center"
       >
-        <svg
-          xmlns="http://www.w3.org/2000/svg"
-          fill="none"
-          viewBox="0 0 24 24"
-          stroke-width="2"
-          stroke="currentColor"
-          class="w-4 h-4 border-transparent border-b-[0.5px]"
+        <div
+          class="h-[1.125rem] w-[1.125rem] bg-stone-800 border-stone-900 mx-[0.1875rem] rounded-full flex items-center justify-center cursor-pointer hover:bg-stone-700"
+          {@rest}
         >
-          <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
-        </svg>
+          <svg
+            xmlns="http://www.w3.org/2000/svg"
+            fill="none"
+            viewBox="0 0 24 24"
+            stroke-width="2"
+            stroke="currentColor"
+            class="w-4 h-4 border-transparent border-b-[0.5px]"
+          >
+            <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
+          </svg>
+        </div>
       </div>
 
       <div
         :if={@toggable}
+        data-settings-control="toggle"
         class={[
-          "h-6 flex items-center",
+          "h-6 w-6 flex-none flex items-center justify-center",
           @disabled && "opacity-50",
           !@disabled && "cursor-pointer"
         ]}
diff --git a/lib/mave_core_web/controllers/dashboard/subtitle_controller.ex b/lib/mave_core_web/controllers/dashboard/media_file_controller.ex
similarity index 64%
rename from lib/mave_core_web/controllers/dashboard/subtitle_controller.ex
rename to lib/mave_core_web/controllers/dashboard/media_file_controller.ex
index 2742f86..b466c80 100644
--- a/lib/mave_core_web/controllers/dashboard/subtitle_controller.ex
+++ b/lib/mave_core_web/controllers/dashboard/media_file_controller.ex
@@ -1,4 +1,4 @@
-defmodule MaveCoreWeb.Dashboard.SubtitleController do
+defmodule MaveCoreWeb.Dashboard.MediaFileController do
   @moduledoc false
 
   use MaveCoreWeb, :controller
@@ -7,6 +7,7 @@ defmodule MaveCoreWeb.Dashboard.SubtitleController do
   alias MaveCore.Assets
   alias MaveCore.Assets.Subtitle
   alias MaveCore.Assets.Video
+  alias MaveCore.AudioDescription
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
   alias MaveCore.Media.Storage
@@ -34,6 +35,52 @@ defmodule MaveCoreWeb.Dashboard.SubtitleController do
     end
   end
 
+  def audio(conn, %{"id" => embed_id, "track_id" => id} = params) do
+    with {:ok, space} <- resolve_space(conn.assigns.current_user, params),
+         {:ok, embed} <- Embeds.resolve_dashboard_embed(space, embed_id),
+         %{} = track <- Assets.get_audio_track_for_embed(id, embed) do
+      download_file(conn, space, embed, track.filename, track.label || track.language || "audio")
+    else
+      _ -> not_found(conn)
+    end
+  end
+
+  def description(conn, %{"id" => embed_id, "track_id" => id, "format" => format} = params) do
+    with true <- format in ["mp3", "vtt"],
+         {:ok, space} <- resolve_space(conn.assigns.current_user, params),
+         {:ok, embed} <- Embeds.resolve_dashboard_embed(space, embed_id),
+         %{} = track <- Assets.get_audio_description_for_embed(id, embed) do
+      filename = if format == "mp3", do: track.audio_filename, else: track.vtt_filename
+      download_file(conn, space, embed, filename, track.label || track.language || "description")
+    else
+      _ -> not_found(conn)
+    end
+  end
+
+  defp download_file(conn, space, embed, filename, label) when is_binary(filename) do
+    key =
+      "#{AudioDescription.version_prefix(embed.hash, Embeds.current_video_version(embed))}/#{filename}"
+
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    case storage_adapter().get(bucket, key, space.region) do
+      {:ok, body} when is_binary(body) ->
+        extension = Path.extname(filename)
+        name = String.replace(label, ~r/[^\p{L}\p{N} _.-]/u, "_") <> extension
+
+        conn
+        |> put_resp_content_type("application/octet-stream")
+        |> put_resp_header("x-content-type-options", "nosniff")
+        |> send_download({:binary, body}, filename: name, disposition: :attachment)
+
+      _ ->
+        not_found(conn)
+    end
+  end
+
+  defp download_file(conn, _space, _embed, _filename, _label), do: not_found(conn)
+  defp not_found(conn), do: conn |> put_status(:not_found) |> text("File not found")
+
   defp resolve_space(current_user, %{"space_id" => space_id}) when is_binary(space_id) do
     case Accounts.set_current_space_by_id(current_user, space_id) do
       {:ok, user} -> current_space(user)
diff --git a/lib/mave_core_web/dashboard_routes.ex b/lib/mave_core_web/dashboard_routes.ex
index 6023022..ab11947 100644
--- a/lib/mave_core_web/dashboard_routes.ex
+++ b/lib/mave_core_web/dashboard_routes.ex
@@ -19,6 +19,19 @@ defmodule MaveCoreWeb.DashboardRoutes do
     path_for(space_or_user, "/videos/#{video_id}/subtitles/#{subtitle_id}/download", [], opts)
   end
 
+  def audio_download_path(space, video_id, track_id) do
+    path_for(space, "/videos/#{video_id}/audio-tracks/#{track_id}/download", [], [])
+  end
+
+  def description_download_path(space, video_id, track_id, format) do
+    path_for(
+      space,
+      "/videos/#{video_id}/audio-descriptions/#{track_id}/#{format}/download",
+      [],
+      []
+    )
+  end
+
   def data_path(space_or_user, opts \\ []) do
     path_for(space_or_user, "/data", period_params(opts), opts)
   end
diff --git a/lib/mave_core_web/live/dashboard/settings/general_tab.ex b/lib/mave_core_web/live/dashboard/settings/general_tab.ex
index db57555..99cca79 100644
--- a/lib/mave_core_web/live/dashboard/settings/general_tab.ex
+++ b/lib/mave_core_web/live/dashboard/settings/general_tab.ex
@@ -9,6 +9,7 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
   alias MaveCore.Spaces
   alias MaveCore.Spaces.Domain
   alias MaveCore.Spaces.Space
+  alias MaveCore.UsageLimits
   alias Phoenix.LiveView.JS
 
   @show_flow_settings false
@@ -182,6 +183,34 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
               </div>
             </:actions>
           </.data_table_row>
+          <.data_table_row id="audio-description-feature">
+            <div>
+              <div>{gettext("Audio description")}</div>
+              <div
+                :if={@features.audio_description_notice}
+                id="audio-description-notice"
+                class="text-xs text-stone-400 mt-1"
+              >
+                {@features.audio_description_notice}
+              </div>
+            </div>
+            <.info_hover>
+              {gettext(
+                "New videos get spoken descriptions of what happens on screen, in English and Dutch: an audio track with the descriptions mixed in, and a descriptions VTT."
+              )}
+            </.info_hover>
+            <:actions>
+              <div class="p-4">
+                <.toggle
+                  id="audio-description-toggle"
+                  enabled={@features.audio_description}
+                  disabled={@features.audio_description_disabled}
+                  phx-click="toggle_audio_description"
+                  phx-target={@myself}
+                />
+              </div>
+            </:actions>
+          </.data_table_row>
         </.data_table>
       </div>
 
@@ -519,6 +548,34 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
     end
   end
 
+  def handle_event("toggle_audio_description", _params, socket) do
+    attrs = %{
+      audio_description_enabled: !socket.assigns.current_space.audio_description_enabled
+    }
+
+    case Spaces.update_space_features(socket.assigns.current_space, attrs) do
+      {:ok, updated_space} ->
+        {:noreply,
+         socket
+         |> notify_parent(updated_space)
+         |> assign(:current_space, updated_space)
+         |> reload_state()}
+
+      {:error, %Ecto.Changeset{}} ->
+        {:noreply, put_flash(socket, :error, gettext("Could not update audio description."))}
+
+      {:error, reason} ->
+        copy = UsageLimits.restriction_copy(:audio_description, reason)
+
+        {:noreply,
+         put_flash(
+           socket,
+           :error,
+           Map.get(copy, :error, gettext("Audio description isn't available for this space."))
+         )}
+    end
+  end
+
   def handle_event("change_default_flow_template", %{"processing" => params}, socket) do
     case Spaces.update_space_processing(socket.assigns.current_space, %{
            default_flow_template: Map.get(params, "default_flow_template")
@@ -634,12 +691,42 @@ defmodule MaveCoreWeb.Dashboard.Settings.GeneralTab do
     |> assign(:region_help, dashboard_region_help(current_space))
     |> assign(:account_deletion_requirements, AccountDeletion.requirements())
     |> assign(:google_oauth_enabled, GoogleOAuth.enabled?())
-    |> assign(:features, %{
-      public_sharing: current_space.public_sharing_enabled,
-      create_spaces: false,
-      hotlink_protection: hotlink_protection_enabled?(current_space),
-      hotlink_protection_disabled: SharedStorageSpace.shared?(current_space)
-    })
+    |> assign(
+      :features,
+      Map.merge(
+        %{
+          public_sharing: current_space.public_sharing_enabled,
+          create_spaces: false,
+          hotlink_protection: hotlink_protection_enabled?(current_space),
+          hotlink_protection_disabled: SharedStorageSpace.shared?(current_space)
+        },
+        audio_description_features(current_space)
+      )
+    )
+  end
+
+  # A space that lost access can still switch the feature off, but not back on.
+  defp audio_description_features(%Space{} = space) do
+    enabled? = space.audio_description_enabled == true
+
+    case UsageLimits.can_use_audio_description?(space) do
+      :ok ->
+        %{
+          audio_description: enabled?,
+          audio_description_disabled: false,
+          audio_description_notice: nil
+        }
+
+      {:error, reason} ->
+        copy = UsageLimits.restriction_copy(:audio_description, reason)
+
+        %{
+          audio_description: enabled?,
+          audio_description_disabled: not enabled?,
+          audio_description_notice:
+            Map.get(copy, :notice, gettext("Audio description isn't available for this space."))
+        }
+    end
   end
 
   defp notify_parent(socket, updated_space) do
diff --git a/lib/mave_core_web/live/dashboard/videos/show.ex b/lib/mave_core_web/live/dashboard/videos/show.ex
index b231e45..9571d70 100644
--- a/lib/mave_core_web/live/dashboard/videos/show.ex
+++ b/lib/mave_core_web/live/dashboard/videos/show.ex
@@ -233,8 +233,13 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
 
   def handle_info({VideoSettingsComponent, {:audio_track_uploaded, pending_track}}, socket) do
     if socket.assigns.resource_embed do
-      previous_signature = media_signature(socket.assigns.video, :audio_tracks)
-      previous_count = socket.assigns.video |> Map.get(:audio_tracks, []) |> length()
+      field =
+        if Map.get(pending_track || %{}, :kind) == :audio_description,
+          do: :audio_descriptions,
+          else: :audio_tracks
+
+      previous_signature = media_signature(socket.assigns.video, field)
+      previous_count = socket.assigns.video |> Map.get(field, []) |> length()
 
       Process.send_after(
         self(),
@@ -368,8 +373,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
   def handle_info({:reload_audio_tracks, embed_id, previous_count, attempts_left}, socket) do
     case resolve_current_video_embed(socket, embed_id) do
       {:ok, %Embed{} = embed} ->
-        audio_count = dashboard_payload_count(socket, embed, :audio_tracks)
-        audio_signature = dashboard_payload_signature(socket, embed, :audio_tracks)
+        field = pending_audio_field(socket)
+        audio_count = dashboard_payload_count(socket, embed, field)
+        audio_signature = dashboard_payload_signature(socket, embed, field)
 
         if audio_count > previous_count or
              uploaded_media_signature_changed?(
@@ -941,7 +947,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
     |> maybe_complete_poster_upload(video_embed, video)
     |> maybe_clear_materialized_media_processing(
       video,
-      :audio_tracks,
+      pending_audio_field(socket),
       :processing_uploaded_audio_track,
       :processing_uploaded_audio_track_signature
     )
@@ -1062,6 +1068,12 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
     end
   end
 
+  defp pending_audio_field(socket) do
+    if get_in(socket.assigns, [:processing_uploaded_audio_track, :kind]) == :audio_description,
+      do: :audio_descriptions,
+      else: :audio_tracks
+  end
+
   defp media_signature(video, field) when is_map(video) do
     video
     |> Map.get(field, [])
@@ -1072,7 +1084,18 @@ defmodule MaveCoreWeb.Dashboard.Videos.Show do
 
   defp media_signature_item(item) when is_map(item) do
     item
-    |> Map.take([:id, :filename, :path, :label, :language, :codec, :file_size, :default])
+    |> Map.take([
+      :id,
+      :filename,
+      :path,
+      :label,
+      :language,
+      :codec,
+      :file_size,
+      :default,
+      :mp3_url,
+      :vtt_url
+    ])
     |> Enum.sort()
   end
 
diff --git a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
index 16d7b5f..bbeb966 100644
--- a/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
+++ b/lib/mave_core_web/live/dashboard/videos/video_settings_component.ex
@@ -3,6 +3,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   use MaveCoreWeb, :live_component
 
+  import MaveCoreWeb.DashboardComponents.Modals, only: [dialog: 1]
   import MaveCoreWeb.DashboardComponents.Settings
   import MaveCoreWeb.DashboardComponents.States, only: [progress_bar: 1]
 
@@ -38,6 +39,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       socket
       |> maybe_allow_poster_upload()
       |> maybe_allow_audio_track_upload()
+      |> maybe_allow_audio_description_upload()
+      |> maybe_allow_audio_description_vtt_upload()
       |> maybe_allow_subtitle_upload()
       |> assign(assigns)
       |> MaveCoreWeb.SpaceLiveAuth.attach_component()
@@ -49,7 +52,10 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       |> assign(:show_flow_info, @show_flow_info)
       |> assign_new(:show_flow_details, fn -> false end)
       |> assign_new(:audio_track_form, fn -> nil end)
+      |> assign_new(:audio_description_form, fn -> nil end)
+      |> assign_new(:audio_description_vtt_form, fn -> nil end)
       |> assign_new(:subtitle_form, fn -> nil end)
+      |> assign_new(:pending_media_delete, fn -> nil end)
 
     socket =
       cond do
@@ -61,7 +67,10 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           |> assign(:uploading_poster, false)
           |> assign(:show_flow_details, false)
           |> assign(:audio_track_form, nil)
+          |> assign(:audio_description_form, nil)
+          |> assign(:audio_description_vtt_form, nil)
           |> assign(:subtitle_form, nil)
+          |> assign(:pending_media_delete, nil)
 
         socket.assigns.has_changes ->
           assign(socket, :persisted_settings, incoming_settings)
@@ -72,6 +81,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           |> assign(:persisted_settings, incoming_settings)
           |> assign(:has_changes, false)
           |> assign(:audio_track_form, nil)
+          |> assign(:audio_description_form, nil)
+          |> assign(:audio_description_vtt_form, nil)
           |> assign(:subtitle_form, nil)
       end
 
@@ -252,6 +263,12 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     update_audio_track_if_changed(socket, id, :label, blank_to_nil(Map.get(params, "label")))
   end
 
+  def handle_event(event, %{"_track_id" => id} = params, socket)
+      when event in ["change_audio_track_language", "change_audio_description_language"] do
+    params = params |> Map.delete("_track_id") |> Map.put("id", id)
+    handle_event(event, params, socket)
+  end
+
   def handle_event("change_audio_track_language", %{"id" => id, "value" => language}, socket) do
     handle_event(
       "change_audio_track_language",
@@ -285,6 +302,84 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  def handle_event("add_audio_description", _params, socket) do
+    {:noreply,
+     assign(socket, :audio_description_form, %{
+       mode: :new,
+       audio_track_id: nil,
+       label: gettext("Audio description"),
+       language: ""
+     })}
+  end
+
+  def handle_event("cancel_audio_description", _params, socket) do
+    {:noreply, assign(socket, :audio_description_form, nil)}
+  end
+
+  def handle_event("change_new_audio_description", %{"audio_track" => params}, socket) do
+    form = socket.assigns.audio_description_form || %{mode: :new, audio_track_id: nil}
+
+    {:noreply,
+     assign(
+       socket,
+       :audio_description_form,
+       Map.merge(form, %{label: params["label"] || "", language: params["language"] || ""})
+     )}
+  end
+
+  def handle_event("replace_audio_description", %{"id" => id}, socket) do
+    case Assets.get_audio_description_for_embed(id, socket.assigns.embed) do
+      nil ->
+        {:noreply, socket}
+
+      track ->
+        {:noreply,
+         assign(socket, :audio_description_form, %{
+           mode: :replace,
+           audio_track_id: track.id,
+           label: track.label || Languages.spoken_language(track.language),
+           language: track.language,
+           picker_ref: System.unique_integer([:positive])
+         })}
+    end
+  end
+
+  def handle_event(event, %{"id" => id} = params, socket)
+      when event in ["blur_audio_description_label", "change_audio_description_language"] do
+    field = if event == "blur_audio_description_label", do: :label, else: :language
+    value = params["value"] || get_in(params, ["audio_track", Atom.to_string(field)])
+
+    audio_description_result(
+      socket,
+      Assets.update_audio_description_outputs(socket.assigns.embed, id, %{
+        field => blank_to_nil(value)
+      })
+    )
+  end
+
+  def handle_event("upload_audio_description_vtt", %{"id" => id}, socket) do
+    case Assets.get_audio_description_for_embed(id, socket.assigns.embed) do
+      nil ->
+        {:noreply, socket}
+
+      description ->
+        {:noreply,
+         assign(socket, :audio_description_vtt_form, %{
+           audio_track_id: description.id,
+           label: description.label,
+           language: description.language,
+           picker_ref: System.unique_integer([:positive])
+         })}
+    end
+  end
+
+  def handle_event("delete_audio_description", %{"id" => id}, socket) do
+    audio_description_result(
+      socket,
+      Assets.delete_audio_description_outputs(socket.assigns.embed, id)
+    )
+  end
+
   def handle_event("add_subtitle", _params, socket) do
     {:noreply,
      assign(socket, :subtitle_form, %{
@@ -359,6 +454,43 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  def handle_event("request_media_delete", %{"kind" => kind, "id" => id}, socket) do
+    target =
+      case kind do
+        "audio_track" -> scoped_audio_track(socket, id)
+        "audio_description" -> Assets.get_audio_description_for_embed(id, socket.assigns.embed)
+        "subtitle" -> scoped_subtitle(socket, id)
+        _ -> nil
+      end
+
+    if target && !Map.get(target, :default, false) do
+      label = Map.get(target, :label) || Map.get(target, :language) || gettext("this track")
+      {:noreply, assign(socket, :pending_media_delete, %{kind: kind, id: id, label: label})}
+    else
+      {:noreply, socket}
+    end
+  end
+
+  def handle_event("cancel_media_delete", _, socket),
+    do: {:noreply, assign(socket, :pending_media_delete, nil)}
+
+  def handle_event("confirm_media_delete", _, socket) do
+    case socket.assigns.pending_media_delete do
+      %{kind: kind, id: id} ->
+        event =
+          %{
+            "audio_track" => "delete_audio_track",
+            "audio_description" => "delete_audio_description",
+            "subtitle" => "delete_subtitle"
+          }[kind]
+
+        handle_event(event, %{"id" => id}, assign(socket, :pending_media_delete, nil))
+
+      _ ->
+        {:noreply, socket}
+    end
+  end
+
   @impl true
   def handle_event("noop", _params, socket), do: {:noreply, socket}
 
@@ -403,6 +535,54 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     {:noreply, socket}
   end
 
+  def handle_progress(:audio_description_file, entry, socket) do
+    form = socket.assigns.audio_description_form || %{}
+
+    pending = %{
+      id: form[:audio_track_id],
+      mode: form[:mode] || :new,
+      label: form[:label],
+      language: form[:language],
+      kind: :audio_description
+    }
+
+    if entry.done? do
+      consume_uploaded_entries(socket, :audio_description_file, fn _meta, _entry ->
+        {:ok, :uploaded}
+      end)
+
+      notify_parent({:audio_track_uploaded, pending})
+      {:noreply, assign(socket, :audio_description_form, nil)}
+    else
+      {:noreply, socket}
+    end
+  end
+
+  def handle_progress(:audio_description_vtt_file, entry, socket) do
+    form = socket.assigns.audio_description_vtt_form || %{}
+
+    if entry.done? do
+      consume_uploaded_entries(socket, :audio_description_vtt_file, fn _, _ ->
+        {:ok, :uploaded}
+      end)
+
+      notify_parent(
+        {:audio_track_uploaded,
+         %{
+           id: form[:audio_track_id],
+           mode: :replace,
+           label: form[:label],
+           language: form[:language],
+           kind: :audio_description
+         }}
+      )
+
+      {:noreply, assign(socket, :audio_description_vtt_form, nil)}
+    else
+      {:noreply, socket}
+    end
+  end
+
   def handle_progress(:subtitle_file, entry, socket) do
     pending_subtitle = pending_subtitle_upload(socket)
 
@@ -470,6 +650,25 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     {:ok, options, socket}
   end
 
+  def presign_audio_description_upload(entry, socket) do
+    description_socket = assign(socket, :audio_track_form, socket.assigns.audio_description_form)
+    {:ok, options, _} = presign_audio_track_upload(entry, description_socket)
+    {:ok, Map.put(options, :audio_description, true), socket}
+  end
+
+  def presign_audio_description_vtt_upload(entry, socket) do
+    form = socket.assigns.audio_description_vtt_form || %{}
+
+    subtitle_socket =
+      assign(socket, :subtitle_form, %{
+        subtitle_id: form[:audio_track_id],
+        language: form[:language]
+      })
+
+    {:ok, options, _} = presign_subtitle_upload(entry, subtitle_socket)
+    {:ok, Map.put(options, :audio_description, true), socket}
+  end
+
   def presign_subtitle_upload(_entry, socket) do
     form = socket.assigns.subtitle_form || %{}
 
@@ -519,6 +718,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
               uploads={@uploads}
               uploading_poster={@uploading_poster}
               audio_track_form={@audio_track_form}
+              audio_description_form={@audio_description_form}
+              audio_description_vtt_form={@audio_description_vtt_form}
               subtitle_form={@subtitle_form}
               processing_uploaded_audio_track={@processing_uploaded_audio_track}
               processing_uploaded_subtitle={@processing_uploaded_subtitle}
@@ -538,6 +739,23 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
           <.tab_navigation current_tab={@current_tab} myself={@myself} />
         </:footer>
       </.settings_panel>
+      <.dialog
+        :if={@pending_media_delete}
+        id="delete-media-dialog"
+        show={true}
+        title={gettext("Delete track?")}
+        confirm_label={gettext("Delete")}
+        confirm_variant="danger"
+        on_confirm={JS.push("confirm_media_delete", target: @myself)}
+        on_cancel={JS.push("cancel_media_delete", target: @myself)}
+      >
+        {gettext("Are you sure you want to delete “%{name}” from this video?",
+          name: @pending_media_delete.label
+        )}
+        <span :if={@pending_media_delete.kind == "audio_description"} class="block mt-2">
+          {gettext("Its audio and description text will both be removed.")}
+        </span>
+      </.dialog>
     </div>
     """
   end
@@ -608,6 +826,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         audio_only={@video.original.audio_only}
         renditions={@video.renditions}
         audio_tracks={@video.audio_tracks}
+        audio_descriptions={Map.get(@video, :audio_descriptions, [])}
         subtitles={@video.subtitles}
       />
 
@@ -868,6 +1087,8 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   attr :uploads, :map, required: true
   attr :uploading_poster, :boolean, required: true
   attr :audio_track_form, :map, default: nil
+  attr :audio_description_form, :map, default: nil
+  attr :audio_description_vtt_form, :map, default: nil
   attr :subtitle_form, :map, default: nil
   attr :processing_uploaded_audio_track, :map, default: nil
   attr :processing_uploaded_subtitle, :map, default: nil
@@ -913,8 +1134,26 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       <.audio_tracks_options_section
         :if={@show_audio_tracks_section}
         tracks={@video.audio_tracks}
+        current_space={@current_space}
+        video_id={@video.id}
         audio_track_form={@audio_track_form}
-        processing_uploaded_audio_track={@processing_uploaded_audio_track}
+        processing_uploaded_audio_track={
+          audio_upload_pending(@processing_uploaded_audio_track, :audio_track)
+        }
+        uploads={@uploads}
+        myself={@myself}
+      />
+      <.audio_tracks_options_section
+        :if={@show_audio_tracks_section}
+        kind={:audio_description}
+        current_space={@current_space}
+        video_id={@video.id}
+        tracks={Map.get(@video, :audio_descriptions, [])}
+        audio_track_form={@audio_description_form}
+        vtt_form={@audio_description_vtt_form}
+        processing_uploaded_audio_track={
+          audio_upload_pending(@processing_uploaded_audio_track, :audio_description)
+        }
         uploads={@uploads}
         myself={@myself}
       />
@@ -1596,9 +1835,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   defp processing_audio_track_row(assigns) do
     ~H"""
-    <div class="relative w-full flex items-center my-1.5 pointer-events-none">
+    <div class="relative w-full flex items-center pointer-events-none">
       <div class="flex-grow border-r border-stone-900 pr-2">
-        <div class="flex flex-col space-y-1.5">
+        <div class="flex flex-col space-y-2">
           <input
             type="text"
             value={Map.get(@track, :label) || gettext("Audio track")}
@@ -1637,13 +1876,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         </div>
       </div>
 
-      <div class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
+      <div class="flex-none h-6 w-6 flex items-center justify-center text-stone-400">
         <.media_spinner />
       </div>
-
-      <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-        <.remove_icon />
-      </div>
     </div>
     """
   end
@@ -1653,7 +1888,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   defp processing_subtitle_row(assigns) do
     ~H"""
-    <div class="relative w-full flex items-center my-1.5 pointer-events-none">
+    <div class="relative w-full flex items-center pointer-events-none">
       <div class="relative flex-grow flex border-r border-stone-900 pr-2">
         <div class="w-full">
           <div class="relative">
@@ -1688,80 +1923,242 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         </div>
       </div>
 
-      <div class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
-        <.download_icon />
-      </div>
-
-      <div class="relative ml-px flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center">
+      <div class="flex-none h-6 w-6 flex items-center justify-center text-stone-400">
         <.media_spinner />
       </div>
-
-      <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-        <.remove_icon />
-      </div>
     </div>
     """
   end
 
-  defp download_icon(assigns) do
+  defp media_spinner(assigns) do
     ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="1.5"
-      stroke="currentColor"
-      class="w-4 h-4"
-    >
-      <path
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        d="M12 4.5v15m0 0l6.75-6.75M12 19.5l-6.75-6.75"
-      />
-    </svg>
+    <div class="h-4 w-4 animate-spin rounded-full border border-stone-500 border-t-transparent"></div>
     """
   end
 
-  defp replace_icon(assigns) do
+  attr :id, :string, required: true
+  attr :trigger_id, :string, required: true
+  attr :label, :string, required: true
+  attr :items, :list, required: true
+  attr :busy, :boolean, default: false
+  attr :myself, :any, required: true
+  slot :inner_block
+
+  defp media_file_menu(assigns) do
     ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="2"
-      stroke="currentColor"
-      class="h-3.5 w-3.5"
+    <div
+      id={"#{@id}-root"}
+      phx-hook="file_menu"
+      data-settings-control="menu"
+      class="relative flex-none h-6 w-6 flex items-center justify-center text-stone-500"
     >
-      <path
-        stroke-linecap="round"
-        stroke-linejoin="round"
-        d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.992 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182"
-      />
-    </svg>
+      <button
+        type="button"
+        id={@trigger_id}
+        aria-label={@label}
+        aria-haspopup="menu"
+        aria-expanded="false"
+        aria-controls={@id}
+        data-file-menu-trigger="true"
+        disabled={@busy}
+        class="flex h-6 w-6 items-center justify-center cursor-pointer rounded-sm transition-colors hover:bg-stone-800 hover:text-stone-300 outline-none focus-visible:bg-stone-800 focus-visible:ring-1 focus-visible:ring-blue-500"
+      >
+        <.media_spinner :if={@busy} />
+        <.icon :if={!@busy} name="hero-ellipsis-horizontal" class="h-4 w-4" />
+      </button>
+      <div
+        id={@id}
+        role="menu"
+        aria-labelledby={@trigger_id}
+        data-file-menu-panel
+        style="display: none;"
+        class="fixed z-[100] w-52 overflow-hidden rounded-lg bg-stone-800 text-sm shadow-xl shadow-black/40 ring-1 ring-white/10"
+      >
+        <div :for={item <- @items} class={item.separator && "border-t border-white/10"}>
+          <a
+            :if={item.href}
+            id={item.id}
+            href={item.href}
+            download={item.filename}
+            role="menuitem"
+            tabindex="-1"
+            class="group flex w-full items-center gap-2.5 px-3.5 py-3 text-left text-stone-200 outline-none transition-colors duration-150 hover:bg-white/[0.05] hover:text-white focus-visible:bg-white/[0.05] focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-white/20 cursor-pointer"
+          >
+            <.icon
+              name={item.icon}
+              class="h-4 w-4 shrink-0 text-stone-400 transition-colors group-hover:text-stone-300 group-focus-visible:text-stone-300"
+            />
+            <span class="flex-1 text-xs font-medium">{item.label}</span>
+            <span
+              :if={item.format}
+              class="rounded border border-stone-600/60 px-1 py-0.5 text-[10px] leading-none text-stone-400"
+            >{item.format}</span>
+          </a>
+          <button
+            :if={!item.href}
+            id={item.id}
+            type="button"
+            role="menuitem"
+            tabindex="-1"
+            disabled={item.disabled}
+            aria-label={item.label}
+            phx-click={JS.push(item.event, target: @myself, value: item.value)}
+            class={[
+              "group flex w-full items-center gap-2.5 px-3.5 py-3 text-left outline-none transition-colors duration-150 focus-visible:ring-1 focus-visible:ring-inset focus-visible:ring-white/20",
+              item.disabled && "opacity-35 cursor-not-allowed",
+              !item.disabled && "hover:bg-white/[0.05] focus-visible:bg-white/[0.05] cursor-pointer",
+              item.danger && "text-red-400",
+              !item.danger && "text-stone-200 hover:text-white"
+            ]}
+          >
+            <.icon
+              name={item.icon}
+              class={[
+                "h-4 w-4 shrink-0 transition-colors",
+                item.danger && "text-red-400",
+                !item.danger &&
+                  "text-stone-400 group-hover:text-stone-300 group-focus-visible:text-stone-300"
+              ]}
+            />
+            <span class="flex-1 text-xs font-medium">{item.label}</span>
+            <span
+              :if={item.format}
+              class="rounded border border-stone-600/60 px-1 py-0.5 text-[10px] leading-none text-stone-400"
+            >{item.format}</span>
+          </button>
+        </div>
+      </div>
+      {render_slot(@inner_block)}
+    </div>
     """
   end
 
-  defp remove_icon(assigns) do
-    ~H"""
-    <svg
-      xmlns="http://www.w3.org/2000/svg"
-      fill="none"
-      viewBox="0 0 24 24"
-      stroke-width="2"
-      stroke="currentColor"
-      class="h-4 w-4 rotate-45"
-    >
-      <path stroke-linecap="round" stroke-linejoin="round" d="M12 4.5v15m7.5-7.5h-15" />
-    </svg>
-    """
+  defp menu_item(id, label, icon, opts) do
+    Map.merge(
+      %{
+        id: id,
+        label: label,
+        icon: icon,
+        href: nil,
+        filename: nil,
+        format: nil,
+        event: nil,
+        value: %{},
+        danger: false,
+        disabled: false,
+        separator: false
+      },
+      Map.new(opts)
+    )
   end
 
-  defp media_spinner(assigns) do
-    ~H"""
-    <div class="h-4 w-4 animate-spin rounded-full border border-stone-500 border-t-transparent"></div>
-    """
+  defp audio_menu_items(kind, track, space, video_id, events) do
+    prefix = if kind == :audio_description, do: "audio-description", else: "audio-track"
+    format = if kind == :audio_description, do: "MP3", else: audio_track_format(track)
+
+    href =
+      if kind == :audio_description,
+        do: DashboardRoutes.description_download_path(space, video_id, track.id, "mp3"),
+        else: DashboardRoutes.audio_download_path(space, video_id, track.id)
+
+    base = [
+      menu_item(
+        "#{prefix}-download-#{track.id}",
+        gettext("Download audio"),
+        "hero-arrow-down-tray",
+        href: href,
+        filename: true,
+        format: format
+      ),
+      menu_item(
+        "#{prefix}-replace-audio-#{track.id}",
+        gettext("Replace audio"),
+        "hero-arrow-path",
+        event: events.replace,
+        value: %{id: track.id},
+        format: format
+      )
+    ]
+
+    text =
+      if kind == :audio_description do
+        download =
+          if track.vtt_url do
+            [
+              menu_item(
+                "#{prefix}-download-vtt-#{track.id}",
+                gettext("Download text"),
+                "hero-arrow-down-tray",
+                href: DashboardRoutes.description_download_path(space, video_id, track.id, "vtt"),
+                filename: true,
+                format: "VTT",
+                separator: true
+              )
+            ]
+          else
+            []
+          end
+
+        download ++
+          [
+            menu_item(
+              "#{prefix}-vtt-#{track.id}",
+              if(track.vtt_url, do: gettext("Replace text"), else: gettext("Upload text")),
+              "hero-document-text",
+              event: "upload_audio_description_vtt",
+              value: %{id: track.id},
+              format: "VTT",
+              separator: download == []
+            )
+          ]
+      else
+        []
+      end
+
+    base ++
+      text ++
+      [
+        menu_item(
+          "delete-#{prefix}-#{track.id}",
+          gettext("Delete"),
+          "hero-trash",
+          event: "request_media_delete",
+          value: %{kind: Atom.to_string(kind), id: track.id},
+          danger: true,
+          separator: true,
+          disabled: track.default
+        )
+      ]
+  end
+
+  defp subtitle_menu_items(subtitle, space, video_id) do
+    [
+      menu_item(
+        "subtitle-download-#{subtitle.id}",
+        gettext("Download text"),
+        "hero-arrow-down-tray",
+        href: DashboardRoutes.subtitle_download_path(space, video_id, subtitle.id),
+        filename: subtitle_download_filename(subtitle),
+        format: "VTT"
+      ),
+      menu_item("subtitle-replace-#{subtitle.id}", gettext("Replace text"), "hero-arrow-path",
+        event: "replace_subtitle",
+        value: %{id: subtitle.id},
+        format: "VTT"
+      ),
+      menu_item("delete-subtitle-#{subtitle.id}", gettext("Delete"), "hero-trash",
+        event: "request_media_delete",
+        value: %{kind: "subtitle", id: subtitle.id},
+        danger: true,
+        separator: true
+      )
+    ]
   end
 
+  attr :current_space, :map, required: true
+  attr :video_id, :string, required: true
+  attr :kind, :atom, default: :audio_track
+  attr :vtt_form, :map, default: nil
   attr :tracks, :list, required: true
   attr :audio_track_form, :map, default: nil
   attr :processing_uploaded_audio_track, :map, default: nil
@@ -1771,12 +2168,38 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   defp audio_tracks_options_section(assigns) do
     assigns = assign(assigns, :language_options, language_options())
     has_tracks = Enum.any?(assigns.tracks || [])
-    assigns = assign(assigns, :has_tracks, has_tracks)
+
+    assigns =
+      assigns
+      |> assign(:has_tracks, has_tracks)
+      |> assign(
+        :heading,
+        if(assigns.kind == :audio_description, do: "audio descriptions", else: "audio tracks")
+      )
+      |> assign(
+        :track_label,
+        if(assigns.kind == :audio_description,
+          do: gettext("Audio description"),
+          else: gettext("Audio track")
+        )
+      )
+      |> assign(
+        :control_prefix,
+        if(assigns.kind == :audio_description, do: "audio-description", else: "audio-track")
+      )
+      |> assign(
+        :upload_name,
+        if(assigns.kind == :audio_description,
+          do: :audio_description_file,
+          else: :audio_track_file
+        )
+      )
+      |> assign(:events, audio_management_events(assigns.kind))
 
     ~H"""
-    <div>
-      <.settings_header title="audio tracks" addable phx-click="add_audio_track" phx-target={@myself} />
-      <div class="pl-3 pr-2.5 py-1.5 text-sm text-stone-400">
+    <div id={"#{@control_prefix}-settings"}>
+      <.settings_header title={@heading} addable phx-click={@events.add} phx-target={@myself} />
+      <div class="px-3 py-1 space-y-2 text-sm text-stone-400">
         <div
           :if={!@has_tracks and is_nil(@audio_track_form) and !@processing_uploaded_audio_track}
           class="h-1"
@@ -1785,29 +2208,32 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         <div
           :for={track <- @tracks}
           class={[
-            "relative w-full flex items-center my-1.5",
+            "relative w-full flex items-center",
             processing_audio_track?(@processing_uploaded_audio_track, track) && "pointer-events-none"
           ]}
         >
           <div class="flex-grow border-r border-stone-900 pr-2">
-            <div class="flex flex-col space-y-1.5">
+            <div class="flex flex-col space-y-2">
               <input
                 name="audio_track[label]"
                 type="text"
                 value={track.label}
-                placeholder="Audio track"
+                placeholder={@track_label}
                 class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent"
-                phx-blur="blur_audio_track_label"
+                phx-blur={@events.blur}
                 phx-target={@myself}
                 phx-value-id={track.id}
               />
-              <div class="relative">
+              <form
+                id={"#{@control_prefix}-language-form-#{track.id}"}
+                class="relative"
+                phx-change={@events.language}
+                phx-target={@myself}
+              >
+                <input type="hidden" name="_track_id" value={track.id} />
                 <select
                   name="audio_track[language]"
                   class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 pr-7 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent appearance-none"
-                  phx-change="change_audio_track_language"
-                  phx-target={@myself}
-                  phx-value-id={track.id}
                 >
                   {Phoenix.HTML.Form.options_for_select(@language_options, track.language || "")}
                 </select>
@@ -1829,97 +2255,52 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
                     />
                   </svg>
                 </div>
-              </div>
-            </div>
-          </div>
-
-          <div class={
-              "relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center #{if active_audio_upload_target?(@audio_track_form, track), do: "hover:bg-stone-600", else: "cursor-pointer hover:bg-stone-600"}"
-            }>
-            <%= if active_audio_upload_target?(@audio_track_form, track) do %>
-              <form
-                id={"audio-track-picker-#{track.id}-#{@audio_track_form[:picker_ref]}"}
-                phx-change="noop"
-                phx-target={@myself}
-                class="absolute inset-0"
-                phx-hook="auto_open_file_picker"
-                data-picker-ref={@audio_track_form[:picker_ref]}
-              >
-                <.live_file_input
-                  upload={@uploads.audio_track_file}
-                  class="absolute inset-0 opacity-0 cursor-pointer"
-                />
               </form>
-            <% end %>
-
-            <%= if (@uploads.audio_track_file.entries != [] and active_audio_upload_target?(@audio_track_form, track)) or
-                      processing_audio_track?(@processing_uploaded_audio_track, track) do %>
-              <.media_spinner />
-            <% else %>
-              <button
-                type="button"
-                class="flex h-full items-center justify-center cursor-pointer"
-                phx-click="replace_audio_track"
-                phx-target={@myself}
-                phx-value-id={track.id}
-              >
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-3.5 w-3.5"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.992 0 3.181 3.183a8.25 8.25 0 0 0 13.803-3.7M4.031 9.865a8.25 8.25 0 0 1 13.803-3.7l3.181 3.182"
-                  />
-                </svg>
-              </button>
-            <% end %>
+            </div>
           </div>
 
-          <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-            <button
-              id={"delete-audio-track-#{track.id}"}
-              type="button"
-              aria-label={gettext("Remove audio track")}
-              class={[
-                "relative w-4 h-6 flex items-center justify-end text-stone-500 phx-click-loading:pointer-events-none phx-click-loading:cursor-wait phx-click-loading:text-stone-300",
-                track.default && "opacity-40 pointer-events-none",
-                !track.default && "cursor-pointer hover:text-stone-300"
-              ]}
-              phx-click={
-                JS.push("delete_audio_track",
-                  target: @myself,
-                  value: %{id: track.id},
-                  loading: "#delete-audio-track-#{track.id}"
-                )
-              }
+          <.media_file_menu
+            id={"#{@control_prefix}-files-#{track.id}"}
+            trigger_id={"#{@control_prefix}-replace-#{track.id}"}
+            label={
+              if @kind == :audio_description,
+                do: gettext("Edit audio description"),
+                else: gettext("Edit audio track")
+            }
+            items={audio_menu_items(@kind, track, @current_space, @video_id, @events)}
+            busy={
+              processing_audio_track?(@processing_uploaded_audio_track, track) ||
+                (@uploads[@upload_name].entries != [] &&
+                   active_audio_upload_target?(@audio_track_form, track))
+            }
+            myself={@myself}
+          >
+            <form
+              :if={active_audio_upload_target?(@audio_track_form, track)}
+              id={"#{@control_prefix}-picker-#{track.id}-#{@audio_track_form[:picker_ref]}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@audio_track_form[:picker_ref]}
             >
-              <span class="inline-flex items-center justify-end phx-click-loading:hidden">
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-4 w-4 rotate-45"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M12 4.5v15m7.5-7.5h-15"
-                  />
-                </svg>
-              </span>
-              <span class="hidden h-4 w-4 items-center justify-center phx-click-loading:inline-flex">
-                <span class="h-3.5 w-3.5 animate-spin rounded-full border border-stone-500 border-t-transparent"></span>
-              </span>
-            </button>
-          </div>
+              <.live_file_input upload={@uploads[@upload_name]} class="absolute inset-0 opacity-0" />
+            </form>
+            <form
+              :if={@vtt_form && @vtt_form.audio_track_id == track.id}
+              id={"audio-description-vtt-picker-#{track.id}-#{@vtt_form.picker_ref}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@vtt_form.picker_ref}
+            >
+              <.live_file_input
+                upload={@uploads.audio_description_vtt_file}
+                class="absolute inset-0 opacity-0"
+              />
+            </form>
+          </.media_file_menu>
         </div>
 
         <.processing_audio_track_row
@@ -1929,19 +2310,19 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         />
 
         <%= if @audio_track_form && @audio_track_form.mode == :new do %>
-          <div class="w-full flex items-center my-1.5">
+          <div class="w-full flex items-center">
             <div class="flex-grow border-r border-stone-900 pr-2">
               <form
-                id="new-audio-track-form"
-                phx-change="change_new_audio_track"
+                id={"new-#{@control_prefix}-form"}
+                phx-change={@events.change}
                 phx-target={@myself}
-                class="flex flex-col space-y-1.5"
+                class="flex flex-col space-y-2"
               >
                 <input
                   name="audio_track[label]"
                   type="text"
                   value={@audio_track_form.label}
-                  placeholder="Audio track"
+                  placeholder={@track_label}
                   class="w-full h-6 bg-stone-800 border-b border-stone-800 px-2 py-0.5 text-sm text-stone-400 outline-none focus:ring-blue-600 ring-1 rounded-sm ring-transparent"
                 />
                 <div class="relative">
@@ -1977,16 +2358,16 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
             </div>
 
             <form
-              id="new-audio-track-upload-form"
+              id={"new-#{@control_prefix}-upload-form"}
               phx-change="noop"
               phx-target={@myself}
               class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600"
             >
               <.live_file_input
-                upload={@uploads.audio_track_file}
+                upload={@uploads[@upload_name]}
                 class="absolute inset-0 opacity-0 cursor-pointer"
               />
-              <%= if @uploads.audio_track_file.entries == [] do %>
+              <%= if @uploads[@upload_name].entries == [] do %>
                 <svg
                   xmlns="http://www.w3.org/2000/svg"
                   fill="none"
@@ -2011,7 +2392,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
               <button
                 type="button"
                 class="w-4 h-6 flex items-center justify-end text-stone-500 cursor-pointer hover:text-stone-300"
-                phx-click="cancel_audio_track"
+                phx-click={@events.cancel}
                 phx-target={@myself}
               >
                 <svg
@@ -2049,7 +2430,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     ~H"""
     <div>
       <.settings_header title="subtitles" addable phx-click="add_subtitle" phx-target={@myself} />
-      <div class="pl-3 pr-2.5 py-1.5 text-sm text-stone-400">
+      <div class="px-3 py-1 space-y-2 text-sm text-stone-400">
         <div
           :if={!@has_subtitles and is_nil(@subtitle_form) and !@processing_uploaded_subtitle}
           class="h-1"
@@ -2058,7 +2439,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         <div
           :for={subtitle <- @subtitles}
           class={[
-            "relative w-full flex items-center my-1.5",
+            "relative w-full flex items-center",
             processing_subtitle?(@processing_uploaded_subtitle, subtitle) && "pointer-events-none"
           ]}
         >
@@ -2099,99 +2480,30 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
             </form>
           </div>
 
-          <a
-            href={DashboardRoutes.subtitle_download_path(@current_space, @video.id, subtitle.id)}
-            download={subtitle_download_filename(subtitle)}
-            class="relative flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600"
+          <.media_file_menu
+            id={"subtitle-files-#{subtitle.id}"}
+            trigger_id={"subtitle-edit-#{subtitle.id}"}
+            label={gettext("Edit subtitles")}
+            items={subtitle_menu_items(subtitle, @current_space, @video.id)}
+            busy={
+              processing_subtitle?(@processing_uploaded_subtitle, subtitle) ||
+                (@uploads.subtitle_file.entries != [] &&
+                   active_subtitle_upload_target?(@subtitle_form, subtitle))
+            }
+            myself={@myself}
           >
-            <svg
-              xmlns="http://www.w3.org/2000/svg"
-              fill="none"
-              viewBox="0 0 24 24"
-              stroke-width="1.5"
-              stroke="currentColor"
-              class="w-4 h-4"
-            >
-              <path
-                stroke-linecap="round"
-                stroke-linejoin="round"
-                d="M12 4.5v15m0 0l6.75-6.75M12 19.5l-6.75-6.75"
-              />
-            </svg>
-          </a>
-
-          <div class="relative ml-px flex-none h-6 px-1 text-sm bg-stone-800 text-stone-400 outline-none overflow-hidden rounded-sm flex items-center justify-center cursor-pointer hover:bg-stone-600">
-            <%= if active_subtitle_upload_target?(@subtitle_form, subtitle) do %>
-              <form
-                id={"subtitle-picker-#{subtitle.id}-#{@subtitle_form[:picker_ref]}"}
-                phx-change="noop"
-                phx-target={@myself}
-                class="absolute inset-0"
-                phx-hook="auto_open_file_picker"
-                data-picker-ref={@subtitle_form[:picker_ref]}
-              >
-                <.live_file_input
-                  upload={@uploads.subtitle_file}
-                  class="absolute inset-0 opacity-0 cursor-pointer"
-                />
-              </form>
-              <%= if @uploads.subtitle_file.entries != [] do %>
-                <.media_spinner />
-              <% else %>
-                <.replace_icon />
-              <% end %>
-            <% else %>
-              <%= if processing_subtitle?(@processing_uploaded_subtitle, subtitle) do %>
-                <.media_spinner />
-              <% else %>
-                <button
-                  type="button"
-                  class="flex h-full items-center justify-center cursor-pointer"
-                  phx-click="replace_subtitle"
-                  phx-target={@myself}
-                  phx-value-id={subtitle.id}
-                >
-                  <.replace_icon />
-                </button>
-              <% end %>
-            <% end %>
-          </div>
-
-          <div class="border-l border-stone-900 flex-none h-6 px-1 text-sm outline-none overflow-hidden rounded-sm flex items-center justify-end">
-            <button
-              id={"delete-subtitle-#{subtitle.id}"}
-              type="button"
-              aria-label={gettext("Remove subtitle")}
-              class="relative w-4 h-6 flex items-center justify-end text-stone-500 cursor-pointer hover:text-stone-300 phx-click-loading:pointer-events-none phx-click-loading:cursor-wait phx-click-loading:text-stone-300"
-              phx-click={
-                JS.push("delete_subtitle",
-                  target: @myself,
-                  value: %{id: subtitle.id},
-                  loading: "#delete-subtitle-#{subtitle.id}"
-                )
-              }
+            <form
+              :if={active_subtitle_upload_target?(@subtitle_form, subtitle)}
+              id={"subtitle-picker-#{subtitle.id}-#{@subtitle_form[:picker_ref]}"}
+              phx-change="noop"
+              phx-target={@myself}
+              class="absolute inset-0 pointer-events-none"
+              phx-hook="auto_open_file_picker"
+              data-picker-ref={@subtitle_form[:picker_ref]}
             >
-              <span class="inline-flex items-center justify-end phx-click-loading:hidden">
-                <svg
-                  xmlns="http://www.w3.org/2000/svg"
-                  fill="none"
-                  viewBox="0 0 24 24"
-                  stroke-width="2"
-                  stroke="currentColor"
-                  class="h-4 w-4 rotate-45"
-                >
-                  <path
-                    stroke-linecap="round"
-                    stroke-linejoin="round"
-                    d="M12 4.5v15m7.5-7.5h-15"
-                  />
-                </svg>
-              </span>
-              <span class="hidden h-4 w-4 items-center justify-center phx-click-loading:inline-flex">
-                <span class="h-3.5 w-3.5 animate-spin rounded-full border border-stone-500 border-t-transparent"></span>
-              </span>
-            </button>
-          </div>
+              <.live_file_input upload={@uploads.subtitle_file} class="absolute inset-0 opacity-0" />
+            </form>
+          </.media_file_menu>
         </div>
 
         <.processing_subtitle_row
@@ -2201,7 +2513,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
         />
 
         <%= if @subtitle_form && @subtitle_form.mode == :new do %>
-          <div class="w-full flex items-center my-1.5">
+          <div class="w-full flex items-center">
             <div class="flex-grow border-r border-stone-900 pr-2">
               <form
                 id="new-subtitle-form"
@@ -2303,6 +2615,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
 
   attr :renditions, :list, required: true
   attr :audio_tracks, :list, default: []
+  attr :audio_descriptions, :list, default: []
   attr :subtitles, :list, default: []
 
   attr :audio_only, :boolean, default: false
@@ -2323,7 +2636,9 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       <%= for {label, types} <- @groups, not (@audio_only and label in ["videos", "clips", "keyframes"]) do %>
         <% grouped = renditions_of_group(@renditions, types) %>
         <% audio_group_rows =
-          if label == "audio", do: audio_group_rows(@audio_tracks, grouped), else: [] %>
+          if label == "audio",
+            do: audio_group_rows(@audio_tracks, grouped, @audio_descriptions),
+            else: [] %>
         <% subtitle_group_rows =
           if label == "subtitles", do: subtitle_group_rows(@subtitles, grouped), else: [] %>
         <%= unless grouped == [] and audio_group_rows == [] and subtitle_group_rows == [] do %>
@@ -2748,7 +3063,7 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       (is_integer(progress) and progress > 0 and progress < 100)
   end
 
-  defp audio_group_rows(audio_tracks, renditions) do
+  defp audio_group_rows(audio_tracks, renditions, audio_descriptions) do
     audio_renditions = Enum.filter(renditions, &(Map.get(&1, :type) == "audio"))
 
     completed_container_badges =
@@ -2759,31 +3074,52 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
       |> Enum.uniq()
       |> Enum.sort_by(&format_index/1)
 
-    audio_tracks
-    |> List.wrap()
-    |> Enum.map(fn track ->
-      base_badges =
-        track
-        |> audio_track_format()
-        |> case do
-          nil -> []
-          format -> [format]
-        end
-
-      label = Map.get(track, :label) || gettext("Audio track")
+    track_rows =
+      audio_tracks
+      |> List.wrap()
+      |> Enum.map(fn track ->
+        base_badges =
+          track
+          |> audio_track_format()
+          |> case do
+            nil -> []
+            format -> [format]
+          end
+
+        label = Map.get(track, :label) || gettext("Audio track")
+
+        %{
+          progress: audio_track_progress(audio_renditions),
+          status: audio_track_status(audio_renditions),
+          size: nil,
+          label: label,
+          badges:
+            (completed_container_badges ++
+               Enum.reject(base_badges, &(&1 in completed_container_badges)))
+            |> Enum.uniq()
+            |> Enum.sort_by(&format_index/1)
+        }
+      end)
 
-      %{
-        progress: audio_track_progress(audio_renditions),
-        status: audio_track_status(audio_renditions),
-        size: nil,
-        label: label,
-        badges:
-          (completed_container_badges ++
-             Enum.reject(base_badges, &(&1 in completed_container_badges)))
-          |> Enum.uniq()
-          |> Enum.sort_by(&format_index/1)
-      }
-    end)
+    rows = if track_rows == [], do: grouped_rows_for("audio", renditions), else: track_rows
+
+    rows ++
+      Enum.map(audio_descriptions, fn description ->
+        %{
+          progress: 100,
+          status: "succeeded",
+          size: nil,
+          label: "#{description.label} (AD)",
+          badges:
+            [
+              {Map.get(description, :hls_playlist), "HLS"},
+              {description.mp3_url, "MP3"},
+              {description.vtt_url, "VTT"}
+            ]
+            |> Enum.filter(fn {url, _format} -> url not in [nil, ""] end)
+            |> Enum.map(fn {_url, format} -> format end)
+        }
+      end)
   end
 
   defp subtitle_group_rows(subtitles, renditions) do
@@ -2944,6 +3280,35 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
   defp upload_error_to_string(other) when is_binary(other), do: other
   defp upload_error_to_string(other), do: inspect(other)
 
+  defp audio_management_events(kind) do
+    name = Atom.to_string(kind)
+
+    %{
+      add: "add_#{name}",
+      replace: "replace_#{name}",
+      delete: "delete_#{name}",
+      change: "change_new_#{name}",
+      cancel: "cancel_#{name}",
+      blur: "blur_#{name}_label",
+      language: "change_#{name}_language"
+    }
+  end
+
+  defp audio_upload_pending(nil, _kind), do: nil
+
+  defp audio_upload_pending(pending, kind) do
+    if Map.get(pending, :kind, :audio_track) == kind, do: pending
+  end
+
+  defp audio_description_result(socket, {:ok, _description}) do
+    notify_parent(:audio_tracks_updated)
+    {:noreply, socket}
+  end
+
+  defp audio_description_result(socket, {:error, _reason}) do
+    {:noreply, put_flash(socket, :error, gettext("Could not update audio description."))}
+  end
+
   defp scoped_audio_track(socket, id) do
     Assets.get_audio_track_for_embed(id, socket.assigns.embed)
   end
@@ -3131,6 +3496,36 @@ defmodule MaveCoreWeb.Dashboard.Videos.VideoSettingsComponent do
     end
   end
 
+  defp maybe_allow_audio_description_upload(socket) do
+    if Map.has_key?(socket.assigns[:uploads] || %{}, :audio_description_file) do
+      socket
+    else
+      allow_upload(socket, :audio_description_file,
+        accept: ~w(.mp3),
+        max_entries: 1,
+        auto_upload: true,
+        external: &presign_audio_description_upload/2,
+        progress: &handle_progress/3,
+        max_file_size: 104_857_600
+      )
+    end
+  end
+
+  defp maybe_allow_audio_description_vtt_upload(socket) do
+    if Map.has_key?(socket.assigns[:uploads] || %{}, :audio_description_vtt_file) do
+      socket
+    else
+      allow_upload(socket, :audio_description_vtt_file,
+        accept: ~w(.vtt),
+        max_entries: 1,
+        max_file_size: 10_485_760,
+        external: &presign_audio_description_vtt_upload/2,
+        progress: &handle_progress/3,
+        auto_upload: true
+      )
+    end
+  end
+
   defp maybe_allow_subtitle_upload(socket) do
     uploads = socket.assigns[:uploads] || %{}
 
diff --git a/lib/mave_core_web/router.ex b/lib/mave_core_web/router.ex
index 20cca1b..3ae471f 100644
--- a/lib/mave_core_web/router.ex
+++ b/lib/mave_core_web/router.ex
@@ -306,11 +306,25 @@ defmodule MaveCoreWeb.Router do
       live "/cli/auth/:user_code", CliAuthLive, :authorize
     end
 
-    get "/videos/:id/subtitles/:subtitle_id/download", Dashboard.SubtitleController, :download
+    get "/videos/:id/subtitles/:subtitle_id/download", Dashboard.MediaFileController, :download
 
     get "/:space_id/videos/:id/subtitles/:subtitle_id/download",
-        Dashboard.SubtitleController,
+        Dashboard.MediaFileController,
         :download
+
+    get "/videos/:id/audio-tracks/:track_id/download", Dashboard.MediaFileController, :audio
+
+    get "/:space_id/videos/:id/audio-tracks/:track_id/download",
+        Dashboard.MediaFileController,
+        :audio
+
+    get "/videos/:id/audio-descriptions/:track_id/:format/download",
+        Dashboard.MediaFileController,
+        :description
+
+    get "/:space_id/videos/:id/audio-descriptions/:track_id/:format/download",
+        Dashboard.MediaFileController,
+        :description
   end
 
   use MaveCoreWeb.DevRoutes
diff --git a/priv/repo/migrations/20261101120000_add_audio_descriptions.exs b/priv/repo/migrations/20261101120000_add_audio_descriptions.exs
new file mode 100644
index 0000000..89e95f6
--- /dev/null
+++ b/priv/repo/migrations/20261101120000_add_audio_descriptions.exs
@@ -0,0 +1,25 @@
+defmodule MaveCore.Repo.Migrations.AddAudioDescriptions do
+  use Ecto.Migration
+
+  def change do
+    alter table(:spaces) do
+      add :audio_description_enabled, :boolean, null: false, default: false
+    end
+
+    create table(:audio_descriptions, primary_key: false) do
+      add :id, :binary_id, primary_key: true
+      add :video_id, references(:videos, type: :binary_id, on_delete: :delete_all), null: false
+      add :language, :language_code, null: false
+      add :audio_filename, :string, null: false
+      add :audio_file_size, :bigint
+      add :vtt_filename, :string, null: false
+      add :vtt_file_size, :bigint
+      add :cue_count, :integer
+      add :ducked_cue_count, :integer
+
+      timestamps(type: :utc_datetime_usec)
+    end
+
+    create unique_index(:audio_descriptions, [:video_id, :language])
+  end
+end
diff --git a/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs b/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs
new file mode 100644
index 0000000..673a0e2
--- /dev/null
+++ b/priv/repo/migrations/20261102100000_manage_audio_descriptions.exs
@@ -0,0 +1,33 @@
+defmodule MaveCore.Repo.Migrations.ManageAudioDescriptions do
+  use Ecto.Migration
+
+  def up do
+    alter table(:audio_descriptions) do
+      add :label, :string
+      add :generation_language, :language_code
+      add :user_managed, :boolean, null: false, default: false
+      add :deleted_at, :utc_datetime_usec
+      modify :vtt_filename, :string, null: true
+    end
+
+    execute "UPDATE audio_descriptions SET generation_language = language"
+    drop unique_index(:audio_descriptions, [:video_id, :language])
+    create unique_index(:audio_descriptions, [:video_id, :generation_language])
+  end
+
+  def down do
+    drop unique_index(:audio_descriptions, [:video_id, :generation_language])
+
+    # User-uploaded tracks may share a language or have no VTT. They cannot be
+    # represented by the previous schema, so require an explicit data migration.
+    create unique_index(:audio_descriptions, [:video_id, :language])
+
+    alter table(:audio_descriptions) do
+      modify :vtt_filename, :string, null: false
+      remove :deleted_at
+      remove :user_managed
+      remove :generation_language
+      remove :label
+    end
+  end
+end
diff --git a/test/mave_core/analytics/sessions_test.exs b/test/mave_core/analytics/sessions_test.exs
index 5a489e8..5e59a5e 100644
--- a/test/mave_core/analytics/sessions_test.exs
+++ b/test/mave_core/analytics/sessions_test.exs
@@ -219,14 +219,29 @@ defmodule MaveCore.Analytics.SessionsTest do
     assert {:ok, 0} = Sessions.refresh_changed(limit: 32)
   end
 
-  test "failed physical invalidation hides pointers and reports an error for retry" do
+  test "invalidation hides pointers and records cleanup without requiring ClickHouse deletion" do
     pair(1, "AAAAA", "video", 20, 25, 0, 5)
     assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, generations} = Sessions.generations("AAAAA")
     ClickHouseRepo.query!("RENAME TABLE analytics_session_years TO temporarily_unavailable_years")
 
     try do
-      assert {:error, :analytics_unavailable} = Sessions.invalidate("AAAAA")
+      assert {:ok, :ok} = Sessions.invalidate("AAAAA")
+      assert {:ok, :ok} = Sessions.invalidate("AAAAA")
       assert {:error, :preparing} = Sessions.generations("AAAAA")
+
+      retired =
+        Repo.query!(
+          "SELECT generation::text FROM analytics_session_retirements WHERE space_hash='AAAAA'"
+        ).rows
+        |> List.flatten()
+
+      assert Enum.sort(retired) == Enum.sort(generations)
+
+      assert [[1]] =
+               ClickHouseRepo.query!(
+                 "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA'"
+               ).rows
     after
       ClickHouseRepo.query!(
         "RENAME TABLE temporarily_unavailable_years TO analytics_session_years"
@@ -234,6 +249,45 @@ defmodule MaveCore.Analytics.SessionsTest do
     end
   end
 
+  test "invalidation preserves the grace period and cleanup cannot remove rebuilt or unrelated data" do
+    pair(1, "AAAAA", "video", 20, 25, 0, 5)
+    pair(2, "BBBBB", "other", 20, 25, 0, 5)
+    assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, old_generations} = Sessions.generations("AAAAA")
+    assert {:ok, other_generations} = Sessions.generations("BBBBB")
+
+    assert {:ok, :ok} = Sessions.invalidate("AAAAA")
+    assert {:error, :preparing} = Sessions.data("AAAAA")
+    assert {:ok, ^other_generations} = Sessions.generations("BBBBB")
+    assert :ok = Sessions.cleanup()
+
+    assert [[1]] =
+             ClickHouseRepo.query!(
+               "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA'"
+             ).rows
+
+    pair(3, "AAAAA", "new-video", 10, 15, 0, 5)
+    assert {:ok, _} = Sessions.refresh_changed(limit: 32)
+    assert {:ok, new_generations} = Sessions.generations("AAAAA")
+    assert MapSet.disjoint?(MapSet.new(old_generations), MapSet.new(new_generations))
+
+    Repo.query!(
+      "UPDATE analytics_session_retirements SET retired_at=now()-interval '2 hours' WHERE space_hash='AAAAA'"
+    )
+
+    assert :ok = Sessions.cleanup()
+    assert {:ok, ^new_generations} = Sessions.generations("AAAAA")
+    assert {:ok, ^other_generations} = Sessions.generations("BBBBB")
+    assert {:ok, %{views: %{year: 2}}} = Sessions.data("AAAAA")
+    assert {:ok, %{views: %{year: 1}}} = Sessions.data("BBBBB")
+
+    assert [[0]] =
+             ClickHouseRepo.query!(
+               "SELECT count() FROM analytics_sessions WHERE space_hash='AAAAA' AND generation IN {$0:Array(UUID)}",
+               [old_generations]
+             ).rows
+  end
+
   test "source deletion invalidates the inventory and cannot retain old totals" do
     pair(1, "AAAAA", "video", 20, 25, 0, 5)
     assert {:ok, _} = Sessions.refresh_changed(limit: 32)
diff --git a/test/mave_core/assets/audio_description_publication_test.exs b/test/mave_core/assets/audio_description_publication_test.exs
new file mode 100644
index 0000000..c73c51c
--- /dev/null
+++ b/test/mave_core/assets/audio_description_publication_test.exs
@@ -0,0 +1,181 @@
+defmodule MaveCore.Assets.AudioDescriptionPublicationTest do
+  use MaveCore.DataCase, async: false
+
+  alias MaveCore.Assets
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Video}
+  alias MaveCore.Embeds.{Embed, ManifestPublisher}
+  alias MaveCore.Flow
+  alias MaveCore.Flow.StepRun
+  alias MaveCore.Spaces.Space
+  alias MaveCore.TestSupport.FlowStorageAdapterStub, as: Storage
+
+  setup do
+    previous = Application.get_env(:mave_core, :flow_storage_adapter)
+    previous_purger = Application.get_env(:mave_core, :cdn_cache_purger)
+    Application.put_env(:mave_core, :flow_storage_adapter, Storage)
+    Application.put_env(:mave_core, :cdn_cache_purger, fn _, _, _ -> :ok end)
+    Storage.reset!()
+
+    on_exit(fn ->
+      restore_env(:flow_storage_adapter, previous)
+      restore_env(:cdn_cache_purger, previous_purger)
+      Storage.reset!()
+    end)
+
+    :ok
+  end
+
+  test "the rebuilt HLS master lists audio descriptions next to the original audio" do
+    embed = embed_fixture()
+    description(embed, "en")
+    description(embed, "nl")
+
+    assert :ok = Assets.refresh_hls_master_playlist(embed)
+    {:ok, body} = Storage.get("space-abcde", "abcdefghij/playlist.m3u8", "eu")
+
+    assert body =~ ~s(NAME="Original",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,CHANNELS="2")
+
+    for {language, name} <- [{"en", "English"}, {"nl", "Dutch"}] do
+      assert body =~
+               ~s|NAME="#{name} (audio description)",LANGUAGE="#{language}",DEFAULT=NO,AUTOSELECT=YES,| <>
+                 ~s|CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",| <>
+                 ~s|URI="audio_description_#{language}_hls/playlist.m3u8"|
+    end
+  end
+
+  test "the manifest has audio descriptions only when there are some" do
+    embed = embed_fixture()
+
+    assert {:ok, manifest} = ManifestPublisher.current(embed)
+    refute Map.has_key?(manifest, "audio_descriptions")
+    assert [%{"filename" => "audio.mp3"}] = manifest["audio_tracks"]
+
+    description(embed, "nl")
+    assert {:ok, manifest} = ManifestPublisher.current(embed)
+
+    assert [
+             %{
+               "language" => "nl",
+               "label" => "Dutch (audio description)",
+               "audio" => %{
+                 "path" => mp3,
+                 "hls_playlist" => "audio_description_nl_hls/playlist.m3u8"
+               },
+               "vtt" => %{"path" => vtt}
+             }
+           ] = manifest["audio_descriptions"]
+
+    assert String.ends_with?(mp3, "/abcdefghij/audio_description_nl.mp3")
+    assert String.ends_with?(vtt, "/abcdefghij/descriptions_nl.vtt")
+    assert [%{"filename" => "audio.mp3"}] = manifest["audio_tracks"]
+  end
+
+  test "late generation updates untouched descriptions and preserves managed or deleted ones" do
+    embed = embed_fixture()
+    original = description(embed, "en")
+
+    {:ok, template} =
+      Flow.create_template(%{"slug" => "description-publication", "name" => "Descriptions"})
+
+    {:ok, _} =
+      Flow.create_version(template.id, %{
+        "definition" => %{
+          "steps" => [
+            %{"id" => "mix", "type" => "media.mix_audio_description", "name" => "Mix"}
+          ]
+        }
+      })
+
+    complete_generation = fn filename ->
+      {:ok, run} =
+        Flow.start_run(
+          template.slug,
+          %{
+            "space_hash" => embed.space.hash,
+            "embed_hash" => embed.hash
+          }, enqueue: false)
+
+      Repo.get_by!(StepRun, flow_run_id: run.id, step_id: "mix")
+      |> StepRun.changeset(%{
+        status: "succeeded",
+        output: %{
+          "status" => "ok",
+          "audio_description" => %{
+            "language" => "en",
+            "audio_filename" => filename,
+            "vtt_filename" => "descriptions_en.vtt"
+          }
+        }
+      })
+      |> Repo.update!()
+
+      assert {:ok, %{status: "succeeded"}} = Flow.reconcile_run(run.id, enqueue_jobs: false)
+    end
+
+    original |> Ecto.Changeset.change(generation_language: "en") |> Repo.update!()
+    complete_generation.("regenerated.mp3")
+    assert Repo.get!(AudioDescription, original.id).audio_filename == "regenerated.mp3"
+
+    original
+    |> Ecto.Changeset.change(user_managed: true, label: "Custom", language: "nl")
+    |> Repo.update!()
+
+    complete_generation.("late.mp3")
+    managed = Repo.get!(AudioDescription, original.id)
+    assert managed.audio_filename == "regenerated.mp3"
+    assert managed.label == "Custom"
+    assert managed.language == "nl"
+
+    managed |> Ecto.Changeset.change(deleted_at: DateTime.utc_now()) |> Repo.update!()
+    complete_generation.("later.mp3")
+    assert Repo.get!(AudioDescription, original.id).deleted_at
+    assert Assets.list_audio_descriptions(embed.asset.current_video.id) == []
+  end
+
+  defp embed_fixture do
+    space = Repo.insert!(%Space{hash: "abcde", region: "eu"})
+    asset = Repo.insert!(%Asset{space_id: space.id})
+    video = Repo.insert!(%Video{asset_id: asset.id, duration: 10.0})
+    asset |> Ecto.Changeset.change(current_video_id: video.id) |> Repo.update!()
+
+    Repo.insert!(%Rendition{
+      video_id: video.id,
+      rendition_key: "abcdefghij/h264_hd_hls/playlist.m3u8",
+      type: :video,
+      codec: :h264,
+      container: :hls,
+      size: :hd,
+      progress: 100.0
+    })
+
+    Repo.insert!(%AudioTrack{
+      video_id: video.id,
+      filename: "audio.mp3",
+      label: "Original",
+      language: "en",
+      codec: "mp3",
+      default: true
+    })
+
+    Repo.insert!(%Embed{space_id: space.id, asset_id: asset.id, hash: "abcdefghij"})
+    |> Repo.preload([:space, asset: [:current_video]])
+  end
+
+  defp description(embed, language) do
+    %AudioDescription{}
+    |> AudioDescription.changeset(%{
+      video_id: embed.asset.current_video.id,
+      language: language,
+      audio_filename: "audio_description_#{language}.mp3",
+      audio_file_size: 1000,
+      vtt_filename: "descriptions_#{language}.vtt",
+      vtt_file_size: 100,
+      cue_count: 2,
+      ducked_cue_count: 1
+    })
+    |> Repo.insert!()
+  end
+
+  defp restore_env(key, nil), do: Application.delete_env(:mave_core, key)
+  defp restore_env(key, value), do: Application.put_env(:mave_core, key, value)
+end
diff --git a/test/mave_core/audio_description/media_test.exs b/test/mave_core/audio_description/media_test.exs
new file mode 100644
index 0000000..84d4f3e
--- /dev/null
+++ b/test/mave_core/audio_description/media_test.exs
@@ -0,0 +1,177 @@
+defmodule MaveCore.AudioDescription.MediaTest do
+  use ExUnit.Case, async: true
+
+  alias MaveCore.AudioDescription.{Cues, Mix, Prompts, Wav}
+
+  describe "Cues" do
+    test "parses timestamps in several formats" do
+      assert Cues.parse_timestamp("00:01:02.500") == 62.5
+      assert Cues.parse_timestamp("01:02") == 62.0
+      assert Cues.parse_timestamp("3,25") == 3.25
+      assert Cues.parse_timestamp(4) == 4.0
+      assert Cues.parse_timestamp("soon") == nil
+      assert Cues.parse_timestamp(-1) == nil
+    end
+
+    test "normalizes cues: sorts, merges equal starts, repairs ends and clamps" do
+      cues =
+        Cues.normalize(
+          [
+            %{"start" => "00:00:04.000", "end" => "00:00:03.000", "text" => " A  door "},
+            %{"start" => 1.0, "end" => 6.0, "text" => "Kitchen."},
+            %{"start" => 1.02, "end" => 2.0, "text" => "Dishes."},
+            %{"start" => 9.8, "end" => 12.0, "text" => "End."},
+            %{"start" => 11.0, "end" => 12.0, "text" => "Past the end."},
+            %{"start" => 2.0, "text" => ""}
+          ],
+          10
+        )
+
+      assert cues == [
+               %{start: 1.0, end: 4.0, text: "Kitchen. Dishes."},
+               %{start: 4.0, end: 5.0, text: "A door"},
+               %{start: 9.8, end: 10.0, text: "End."}
+             ]
+    end
+
+    test "writes a descriptions WebVTT and escapes markup" do
+      vtt = Cues.to_vtt([%{start: 1.0, end: 2.5, text: "Tom & <Jerry>"}], "nl")
+
+      assert vtt ==
+               "WEBVTT\nKind: descriptions\nLanguage: nl\n\n1\n00:00:01.000 --> 00:00:02.500\nTom &amp; &lt;Jerry&gt;\n"
+    end
+
+    test "round-trips through JSON with the scene" do
+      cues = [%{start: 1.0, end: 2.0, text: "a", scene: %{start: 0.0, end: 3.0}}]
+
+      assert cues |> Cues.to_json() |> Jason.encode!() |> Jason.decode!() |> Cues.from_json() ==
+               cues
+    end
+  end
+
+  describe "Wav" do
+    test "decodes 16-bit stereo WAV, downmixes and keeps the rate" do
+      samples =
+        <<1000::little-signed-16, 3000::little-signed-16, -200::little-signed-16,
+          -400::little-signed-16>>
+
+      {:ok, {mono, rate}} = Wav.decode(wav(samples, 2, 48_000, 16))
+
+      assert rate == 48_000
+      assert mono == <<2000::little-signed-16, -300::little-signed-16>>
+    end
+
+    test "decodes 32-bit float WAV" do
+      {:ok, {mono, 24_000}} = Wav.decode(wav(<<0.5::little-float-32>>, 1, 24_000, 32, 3))
+      assert mono == <<16_384::little-signed-16>>
+    end
+
+    test "treats bytes without a header as raw 24 kHz PCM" do
+      assert Wav.decode(<<1, 0, 2, 0, 3>>) == {:ok, {<<1, 0, 2, 0>>, 24_000}}
+    end
+
+    test "resamples linearly" do
+      input = for s <- [0, 100, 200, 300], into: <<>>, do: <<s::little-signed-16>>
+      assert Wav.resample(input, 48_000, 24_000) == <<0::little-signed-16, 200::little-signed-16>>
+    end
+
+    test "trims near-silence and keeps padding" do
+      quiet = :binary.copy(<<0, 0>>, 100)
+      loud = :binary.copy(<<1000::little-signed-16>>, 10)
+      trimmed = Wav.trim_silence(quiet <> loud <> quiet, 1000, 400, 0.005)
+
+      assert byte_size(trimmed) == (10 + 5 + 5) * 2
+      assert Wav.trim_silence(quiet) == <<>>
+    end
+
+    test "renders clips on a timeline with silence in between" do
+      clip = <<7::little-signed-16, 7::little-signed-16>>
+
+      rendered =
+        [%{index: 0, start: 1, length: 2}, %{index: 1, start: 4, length: 2}]
+        |> Wav.render(8, fn _ -> clip end)
+        |> IO.iodata_to_binary()
+
+      assert for(<<s::little-signed-16 <- rendered>>, do: s) == [0, 7, 7, 0, 7, 7, 0, 0]
+    end
+  end
+
+  describe "Mix" do
+    test "ducks with a trapezoid per interval" do
+      assert Mix.duck_expression([]) == "1"
+
+      assert Mix.duck_expression([%{start: 2.0, end: 4.0}, %{start: 6.0, end: 7.0}]) ==
+               "1-0.800*max(clip(min((t-1.700)/0.300,(4.300-t)/0.300),0,1)," <>
+                 "clip(min((t-5.700)/0.300,(7.300-t)/0.300),0,1))"
+    end
+
+    test "mixes the original audio with the description track" do
+      args = Mix.ffmpeg_args("orig.mp3", "desc.pcm", "out.mp3", [%{start: 1.0, end: 2.0}], 10.0)
+
+      assert [
+               "-y",
+               "-v",
+               "error",
+               "-i",
+               "orig.mp3",
+               "-f",
+               "s16le",
+               "-ar",
+               "24000",
+               "-ac",
+               "1",
+               "-i",
+               "desc.pcm" | _
+             ] =
+               args
+
+      filter = Enum.at(args, Enum.find_index(args, &(&1 == "-filter_complex")) + 1)
+      assert filter =~ "volume='1-0.800*clip("
+      assert filter =~ "amix=inputs=2:duration=first:normalize=0,alimiter=limit=0.97[out]"
+      assert List.last(args) == "out.mp3"
+    end
+
+    test "pads the descriptions to the video length when there is no original audio" do
+      args = Mix.ffmpeg_args(nil, "desc.pcm", "out.mp3", [], 12.5)
+      refute "orig.mp3" in args
+      assert Enum.any?(args, &(&1 =~ "apad=whole_dur=12.500"))
+    end
+  end
+
+  describe "Prompts" do
+    test "puts the duration and timing into the describer's instructions" do
+      text = Prompts.describe_instruction(12.0, "Scenes ...")
+      assert text =~ "The video is 12.000 seconds long"
+      assert String.ends_with?(text, "Scenes ...")
+      refute text =~ "\n\n"
+    end
+
+    test "builds the translation request with time slots" do
+      {instruction, input} =
+        Prompts.translation_request([%{start: 1.0, end: 2.26, text: "A door opens."}], "nl")
+
+      assert instruction =~ "into Dutch (nl)"
+      assert input == [%{"i" => 0, "seconds" => 1.3, "text" => "A door opens."}]
+    end
+
+    test "requires exactly one translation per cue" do
+      assert Prompts.check_translations([" Een deur. "], 1) == {:ok, ["Een deur."]}
+      assert {:error, _} = Prompts.check_translations(["a", ""], 2)
+      assert {:error, _} = Prompts.check_translations(["a"], 2)
+    end
+  end
+
+  defp wav(data, channels, rate, bits, tag \\ 1) do
+    block = channels * div(bits, 8)
+
+    fmt =
+      <<tag::little-16, channels::little-16, rate::little-32, rate * block::little-32,
+        block::little-16, bits::little-16>>
+
+    body =
+      <<"WAVE", "fmt ", byte_size(fmt)::little-32, fmt::binary, "data",
+        byte_size(data)::little-32, data::binary>>
+
+    <<"RIFF", byte_size(body)::little-32, body::binary>>
+  end
+end
diff --git a/test/mave_core/audio_description/timeline_test.exs b/test/mave_core/audio_description/timeline_test.exs
new file mode 100644
index 0000000..53eb9cf
--- /dev/null
+++ b/test/mave_core/audio_description/timeline_test.exs
@@ -0,0 +1,281 @@
+defmodule MaveCore.AudioDescription.TimelineTest do
+  use ExUnit.Case, async: true
+
+  alias MaveCore.AudioDescription.Timeline
+
+  # 1 sample = 1 ms keeps the numbers readable.
+  @sr 1000
+
+  defp i(start, stop), do: %{start: start * 1.0, end: stop * 1.0}
+
+  describe "speech_from_words/2" do
+    test "merges close words, pads and clamps" do
+      speech =
+        Timeline.speech_from_words(
+          [i(0.72, 1.28), i(1.28, 2.68), i(4.82, 5.38), i(5.6, 6.68), i(9.9, 10.4)],
+          10
+        )
+
+      assert speech == [i(0.57, 2.83), i(4.67, 6.83), i(9.75, 10)]
+    end
+
+    test "returns nothing for silence" do
+      assert Timeline.speech_from_words([], 30) == []
+    end
+  end
+
+  describe "free_gaps/2" do
+    test "returns the pauses between speech" do
+      assert Timeline.free_gaps([i(2, 4), i(6, 7)], 10) == [i(0, 2), i(4, 6), i(7, 10)]
+    end
+
+    test "is the whole video without speech, and empty when speech never stops" do
+      assert Timeline.free_gaps([], 30) == [i(0, 30)]
+      assert Timeline.free_gaps([i(0, 30)], 30) == []
+    end
+  end
+
+  describe "plan_timeline/5" do
+    @speech [%{start: 2.0, end: 4.0}, %{start: 6.0, end: 9.0}]
+
+    test "keeps a description that fits its pause, without ducking" do
+      t = Timeline.plan_timeline([cue(0.5, 1.5, "A door opens.")], [1200], @speech, 10, @sr)
+
+      assert t.placements == [%{index: 0, start: 500, length: 1200}]
+      assert t.cues == [cue(0.5, 1.7, "A door opens.")]
+      assert t.ducks == []
+      assert t.total_samples == 10_000
+    end
+
+    test "moves a description into a nearby pause when the whole clip fits there" do
+      t = Timeline.plan_timeline([cue(3.5, 5, "She sits down.")], [1500], @speech, 10, @sr)
+
+      assert hd(t.cues) == cue(4, 5.5, "She sits down.")
+      assert t.ducks == []
+    end
+
+    test "plays over speech and ducks when no pause fits" do
+      t = Timeline.plan_timeline([cue(6.5, 9, "Long description.")], [3000], @speech, 10, @sr)
+
+      assert hd(t.cues) == cue(6.5, 9.5, "Long description.")
+      assert t.ducks == [i(6.5, 9.5)]
+    end
+
+    test "never overlaps two descriptions and keeps the clip inside the video" do
+      t =
+        Timeline.plan_timeline(
+          [cue(0, 1, "a"), cue(0.5, 1, "b"), cue(9.5, 10, "c")],
+          [1500, 1000, 2000],
+          [],
+          10,
+          @sr
+        )
+
+      assert Enum.map(t.cues, &{&1.start, &1.end}) == [{0.0, 1.5}, {1.65, 2.65}, {8.0, 10.0}]
+      assert t.ducks == []
+    end
+
+    test "skips descriptions without speech audio" do
+      t = Timeline.plan_timeline([cue(1, 2, "a")], [0], [], 10, @sr)
+      assert t.placements == []
+      assert t.cues == []
+    end
+  end
+
+  describe "plan_timeline/5 with scenes" do
+    @speech [
+      %{start: 4.35, end: 8.91},
+      %{start: 9.43, end: 10.41},
+      %{start: 11.97, end: 15.59}
+    ]
+    @lawn %{start: 7.88, end: 10.24}
+
+    test "never moves a description into a pause after its scene has ended" do
+      t =
+        Timeline.plan_timeline(
+          [Map.put(cue(8, 9.5, "An un-mowed lawn."), :scene, @lawn)],
+          [1600],
+          @speech,
+          27,
+          @sr
+        )
+
+      assert hd(t.cues).start == 8.0
+      assert t.ducks == [i(8, 9.6)]
+    end
+
+    test "uses a pause inside the scene when the clip fits there" do
+      scene = %{start: 10.24, end: 13.28}
+      t = Timeline.plan_timeline([cue(11.5, 12.5, "A messy attic.")], [1200], @speech, 27, @sr)
+      assert hd(t.cues) == cue(10.77, 11.97, "A messy attic.")
+
+      in_scene =
+        Timeline.plan_timeline(
+          [Map.put(cue(10.3, 12, "A messy attic."), :scene, scene)],
+          [1200],
+          @speech,
+          27,
+          @sr
+        )
+
+      assert hd(in_scene.cues).start >= scene.start
+      assert in_scene.ducks == []
+    end
+
+    test "skips a description that earlier long ones pushed out of its scene" do
+      t =
+        Timeline.plan_timeline(
+          [
+            Map.put(cue(0, 2, "A very long first description."), :scene, i(0, 3)),
+            Map.put(cue(3, 4, "Second shot."), :scene, i(3, 4)),
+            Map.put(cue(4, 9, "Third shot."), :scene, i(4, 10))
+          ],
+          [5000, 1000, 1000],
+          [],
+          10,
+          @sr
+        )
+
+      assert t.skipped == [1]
+      assert Enum.map(t.cues, & &1.text) == ["A very long first description.", "Third shot."]
+      assert Enum.at(t.cues, 1).start == 5.15
+    end
+
+    test "speaks at least half of the clip during its scene" do
+      t =
+        Timeline.plan_timeline([Map.put(cue(1.8, 2, "a"), :scene, i(0, 2))], [1000], [], 10, @sr)
+
+      assert hd(t.cues).start <= 1.5
+    end
+  end
+
+  test "shots_from_cuts/2 turns cut times into shot intervals" do
+    assert Timeline.shots_from_cuts([5.28, 7.88, 30], 10) == [
+             i(0, 5.28),
+             i(5.28, 7.88),
+             i(7.88, 10)
+           ]
+
+    assert Timeline.shots_from_cuts([], 10) == [i(0, 10)]
+  end
+
+  describe "timing_prompt/4" do
+    test "lists numbered scenes, speech and numbered pauses with word budgets" do
+      assert Timeline.timing_prompt([i(1, 3)], [i(0, 2), i(2, 5)], 5) ==
+               Enum.join(
+                 [
+                   "Scenes (index: seconds), from cut detection; quick cuts are grouped into one scene:",
+                   "S0: 0.00-2.00",
+                   "S1: 2.00-5.00",
+                   "Speech (seconds): 1.00-3.00",
+                   "Pauses without speech (index: seconds, length, max words):",
+                   "P0: 0.00-1.00 (1.0 s, max 2 words)",
+                   "P1: 3.00-5.00 (2.0 s, max 4 words)"
+                 ],
+                 "\n"
+               )
+    end
+
+    test "budgets about 2.5 words per second with a small margin" do
+      assert Timeline.word_budget(0.5) == 0
+      assert Timeline.word_budget(1.5) == 3
+      assert Timeline.word_budget(4) == 9
+    end
+
+    test "with a window lists only overlapping scenes and pauses, with their global numbers" do
+      scenes = [i(0, 5), i(5, 10), i(10, 15)]
+      speech = [i(1, 4), i(6, 9), i(11, 14)]
+      text = Timeline.timing_prompt(speech, scenes, 15, i(5, 10))
+
+      assert text =~ "S1: 5.00-10.00"
+      refute text =~ "S0:"
+      refute text =~ "S2:"
+      assert text =~ "P1: 4.00-6.00"
+      assert text =~ "P2: 9.00-11.00"
+      refute text =~ "P0:"
+      assert text =~ "Speech (seconds): 6.00-9.00"
+    end
+  end
+
+  describe "snap_cues/3" do
+    @gaps [%{start: 0.0, end: 0.5}, %{start: 2.8, end: 4.4}, %{start: 10.4, end: 12.0}]
+    @scenes [%{start: 0.0, end: 5.0}, %{start: 7.9, end: 10.2}, %{start: 10.2, end: 13.0}]
+
+    test "moves a cue into its pause when the pause overlaps its scene" do
+      assert Timeline.snap_cues(
+               [%{start: 1.07, end: 2.5, text: "Kitchen.", pause: 1, scene: 0}],
+               @gaps,
+               @scenes
+             ) == [%{start: 2.8, end: 3.3, text: "Kitchen.", scene: i(0, 5)}]
+    end
+
+    test "ignores a pause outside the scene, so the description stays in sync" do
+      [cue] =
+        Timeline.snap_cues(
+          [%{start: 10.42, end: 11.9, text: "A lawn.", pause: 2, scene: 1}],
+          @gaps,
+          @scenes
+        )
+
+      assert cue.start < 10.2
+      assert cue.start >= 7.9
+      assert cue.scene == i(7.9, 10.2)
+    end
+
+    test "finds the scene from the start time when the model gave none" do
+      assert Timeline.snap_cues(
+               [%{start: 8.5, end: 9.5, text: "x", pause: -1, scene: nil}],
+               @gaps,
+               @scenes
+             ) == [%{start: 8.5, end: 9.5, text: "x", scene: i(7.9, 10.2)}]
+    end
+  end
+
+  describe "plan_stills/4" do
+    test "takes at least one still per shot and one per ~3 s in longer shots, never on a cut" do
+      assert Timeline.plan_stills([i(0, 1), i(1, 10)], 10) == [
+               %{scene: 0, time: 0.5},
+               %{scene: 1, time: 2.5},
+               %{scene: 1, time: 5.5},
+               %{scene: 1, time: 8.5}
+             ]
+    end
+
+    test "covers a video without cuts as one shot" do
+      assert Timeline.plan_stills([], 6) == [%{scene: 0, time: 1.5}, %{scene: 0, time: 4.5}]
+    end
+
+    test "batches stills to the provider's image limit, in order" do
+      stills = Timeline.plan_stills([i(0, 75)], 75)
+      batches = Timeline.batch_stills(stills, 12)
+
+      assert Enum.map(batches, &length/1) == [12, 12, 1]
+      assert List.flatten(batches) == stills
+    end
+
+    test "takes a still from every cut, labelled with its scene" do
+      cuts = [i(0, 1.2), i(1.2, 2.4), i(2.4, 3.6)]
+      scenes = Timeline.scenes_from_shots(cuts)
+
+      assert Timeline.plan_stills(scenes, 3.6, 3, cuts) == [
+               %{scene: 0, time: 0.6},
+               %{scene: 0, time: 1.8},
+               %{scene: 0, time: 3.0}
+             ]
+    end
+  end
+
+  describe "scenes_from_shots/2" do
+    test "groups quick cuts into scenes of at least 3 s and keeps long shots as they are" do
+      cuts = [i(0, 1.3), i(1.3, 2.6), i(2.6, 3.9), i(3.9, 10), i(10, 11.2)]
+      assert Timeline.scenes_from_shots(cuts) == [i(0, 3.9), i(3.9, 11.2)]
+    end
+
+    test "keeps a single short video as one scene" do
+      assert Timeline.scenes_from_shots([i(0, 2)]) == [i(0, 2)]
+      assert Timeline.scenes_from_shots([]) == []
+    end
+  end
+
+  defp cue(start, stop, text), do: %{start: start * 1.0, end: stop * 1.0, text: text}
+end
diff --git a/test/mave_core/audio_description_test.exs b/test/mave_core/audio_description_test.exs
new file mode 100644
index 0000000..5168d21
--- /dev/null
+++ b/test/mave_core/audio_description_test.exs
@@ -0,0 +1,100 @@
+defmodule MaveCore.AudioDescriptionTest do
+  use MaveCore.DataCase, async: false
+
+  alias MaveCore.Accounts
+  alias MaveCore.AudioDescription
+  alias MaveCore.Repo
+  alias MaveCore.Spaces
+  alias MaveCore.Spaces.Space
+
+  defmodule PaidOnly do
+    @behaviour MaveCore.UsageLimits
+
+    def can_create_video_embed?(_space), do: :ok
+    def can_add_space_member?(_space, _role), do: :ok
+    def can_use_audio_description?(_space), do: {:error, :paid_plan_required}
+  end
+
+  setup do
+    old_backend = Application.get_env(:mave_core, :usage_limits_backend)
+
+    on_exit(fn ->
+      if old_backend,
+        do: Application.put_env(:mave_core, :usage_limits_backend, old_backend),
+        else: Application.delete_env(:mave_core, :usage_limits_backend)
+    end)
+
+    {:ok, user} = Accounts.create_user("ad-#{System.unique_integer([:positive])}@example.com")
+    %{space: user.current_space_membership.space}
+  end
+
+  test "spaces opt in; without a host policy every space may", %{space: space} do
+    refute space.audio_description_enabled
+    assert AudioDescription.run_input(space) == nil
+
+    assert {:ok, %Space{audio_description_enabled: true} = space} =
+             Spaces.update_space_features(space, %{audio_description_enabled: true})
+
+    assert AudioDescription.run_input(space) == %{
+             "languages" => ["original"],
+             "fallback_language" => "en"
+           }
+
+    assert Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "the host decides who may turn it on", %{space: space} do
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+
+    assert {:error, :paid_plan_required} =
+             Spaces.update_space_features(space, %{audio_description_enabled: true})
+
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "a space that lost access stops getting descriptions and can still turn them off", %{
+    space: space
+  } do
+    {:ok, space} = Spaces.update_space_features(space, %{audio_description_enabled: true})
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+
+    refute Spaces.audio_description_active?(space)
+    assert AudioDescription.run_input(space) == nil
+
+    assert {:ok, %Space{audio_description_enabled: false}} =
+             Spaces.update_space_features(space, %{audio_description_enabled: false})
+  end
+
+  test "English is always described first" do
+    assert AudioDescription.requested_languages(%{}) == []
+
+    assert AudioDescription.requested_languages(%{
+             "audio_description" => %{"languages" => ["nl"]}
+           }) == ["en", "nl"]
+  end
+
+  test "original language uses transcription and defaults to English when unknown" do
+    assert AudioDescription.original_language(%{}, %{"transcribe_audio" => %{"language" => "nl"}}) ==
+             "nl"
+
+    assert AudioDescription.original_language(%{"language" => "fr-FR"}, %{}) == "fr"
+    assert AudioDescription.original_language(%{}, %{}) == "en"
+    assert AudioDescription.original_language(%{"language" => "und"}, %{}) == "en"
+
+    assert AudioDescription.requested_languages(%{
+             "audio_description" => %{"languages" => ["original"]}
+           }) == ["original"]
+  end
+
+  test "a flow or step can specify its fallback without overriding detected speech" do
+    input = %{"audio_description" => %{"fallback_language" => "nl"}}
+    assert AudioDescription.original_language(input, %{}) == "nl"
+    assert AudioDescription.original_language(input, %{}, "de") == "de"
+
+    assert AudioDescription.original_language(
+             input,
+             %{"transcribe_audio" => %{"language" => "fr"}},
+             "de"
+           ) == "fr"
+  end
+end
diff --git a/test/mave_core/flow/steps/audio_description_steps_test.exs b/test/mave_core/flow/steps/audio_description_steps_test.exs
new file mode 100644
index 0000000..57b7e6e
--- /dev/null
+++ b/test/mave_core/flow/steps/audio_description_steps_test.exs
@@ -0,0 +1,557 @@
+defmodule MaveCore.Flow.Steps.AudioDescriptionStepsTest do
+  use ExUnit.Case, async: false
+
+  alias MaveCore.Flow.{Definition, Presets, StepRegistry}
+
+  alias MaveCore.Flow.Steps.{
+    AiDescribeVideoStep,
+    AiSpeakDescriptionsStep,
+    AiTranslateDescriptionsStep,
+    AudioDescriptionSupport,
+    MediaBuildHlsMasterStep,
+    MediaDetectScenesStep,
+    MediaMixAudioDescriptionStep
+  }
+
+  alias MaveCore.TestSupport.FlowStorageAdapterStub, as: Storage
+
+  @space "ubg50"
+  @embed "LeDE9v86ye"
+  @bucket "space-ubg50"
+  @requested %{"languages" => ["en", "nl"]}
+
+  defmodule DecodedJsonStorage do
+    def get(_bucket, "object.json", _region), do: {:ok, %{"duration" => 12}}
+    def get(_bucket, "array.json", _region), do: {:ok, [%{"text" => "A red square."}]}
+  end
+
+  test "working JSON accepts bodies already decoded by the HTTP storage adapter" do
+    ctx = %{storage: DecodedJsonStorage, bucket: "test", region: nil}
+
+    assert {:ok, %{"duration" => 12}} =
+             AudioDescriptionSupport.get_json(ctx, "object.json")
+
+    assert {:ok, [%{"text" => "A red square."}]} =
+             AudioDescriptionSupport.get_json(ctx, "array.json")
+  end
+
+  defmodule ChatStub do
+    @moduledoc false
+
+    # Describes every batch of stills with one cue per scene and translates by prefixing.
+    def chat_json(system, content, opts) do
+      send(Process.get(:ad_test_pid) || self(), {:chat, system, content})
+
+      case opts[:schema]["required"] do
+        ["duration_seconds", "cues"] ->
+          images = Enum.count(content, &(&1["type"] == "image_url"))
+          if images == 0, do: raise("no stills sent")
+
+          {:ok,
+           %{
+             "duration_seconds" => 8,
+             "cues" => [
+               cue(0, 0, "00:00:00.200", "00:00:01.000", "A red screen."),
+               cue(1, -1, "00:00:05.500", "00:00:06.500", "It turns blue.")
+             ]
+           }}
+
+        ["translations"] ->
+          [%{"text" => json}] = content
+          {:ok, %{"translations" => json |> Jason.decode!() |> Enum.map(&"NL #{&1["text"]}")}}
+      end
+    end
+
+    defp cue(shot, pause, start, stop, text),
+      do: %{
+        "shot" => shot,
+        "pause" => pause,
+        "max_words" => 4,
+        "start" => start,
+        "end" => stop,
+        "text" => text
+      }
+  end
+
+  defmodule SpeechStub do
+    @moduledoc false
+
+    # One second of a 440 Hz tone as a 24 kHz WAV.
+    def speak(_text, language) do
+      send(test_pid(), {:speak, language})
+
+      pcm =
+        for i <- 0..23_999, into: <<>> do
+          <<round(8000 * :math.sin(i * 2 * :math.pi() * 440 / 24_000))::little-signed-16>>
+        end
+
+      size = byte_size(pcm)
+
+      {:ok,
+       <<"RIFF", size + 36::little-32, "WAVEfmt ", 16::little-32, 1::little-16, 1::little-16,
+         24_000::little-32, 48_000::little-32, 2::little-16, 16::little-16, "data",
+         size::little-32, pcm::binary>>}
+    end
+
+    # Speech runs in tasks; report to the test process that started them.
+    defp test_pid, do: Process.get(:ad_test_pid) || List.last(Process.get(:"$callers", [self()]))
+  end
+
+  setup do
+    old = %{
+      storage: Application.get_env(:mave_core, :flow_storage_adapter),
+      direct: Application.get_env(:mave_core, :flow_direct_storage_ffmpeg_input),
+      ad: Application.get_env(:mave_core, :audio_description)
+    }
+
+    Application.put_env(:mave_core, :flow_storage_adapter, Storage)
+    Application.put_env(:mave_core, :flow_direct_storage_ffmpeg_input, false)
+
+    Application.put_env(:mave_core, :audio_description,
+      chat_provider: ChatStub,
+      speech_provider: SpeechStub
+    )
+
+    Storage.reset!()
+
+    on_exit(fn ->
+      restore(:flow_storage_adapter, old.storage)
+      restore(:flow_direct_storage_ffmpeg_input, old.direct)
+      restore(:audio_description, old.ad)
+    end)
+
+    :ok
+  end
+
+  test "the publishing presets contain optional background steps that nothing waits for" do
+    for slug <- ["publish_default", "publish_local", "publish_remote", "publish_remote_local"] do
+      {:ok, preset} = Presets.fetch(slug)
+      definition = preset["definition"]
+      assert :ok = Definition.validate(definition)
+      steps = definition["steps"]
+
+      ids =
+        ~w(detect_scenes describe_video speak_descriptions_original mix_audio_description_original)
+
+      refute Enum.any?(steps, &(&1["type"] == "ai.translate_descriptions"))
+      assert Enum.count(steps, &(&1["type"] == "media.mix_audio_description")) == 1
+
+      for id <- ids do
+        step = Enum.find(steps, &(&1["id"] == id))
+        assert %{"required" => false, "lane" => "background"} = step
+        assert StepRegistry.known_type?(step["type"])
+        refute Enum.any?(steps, &(id in Map.get(&1, "depends_on", []) and &1["id"] not in ids))
+      end
+    end
+
+    assert StepRegistry.executor_for("media.detect_scenes") == :flame
+    assert StepRegistry.executor_for("media.mix_audio_description") == :flame
+    assert StepRegistry.executor_for("ai.describe_video") == :inline
+  end
+
+  test "every step skips itself when the run didn't ask for audio description" do
+    context = %{run_input: base_input(), dependency_outputs: %{}}
+
+    for {module, params} <- [
+          {MediaDetectScenesStep, %{}},
+          {AiDescribeVideoStep, %{}},
+          {AiTranslateDescriptionsStep, %{"language" => "nl"}},
+          {AiSpeakDescriptionsStep, %{"language" => "en"}},
+          {MediaMixAudioDescriptionStep, %{"language" => "en"}}
+        ] do
+      assert {:ok, %{"status" => "skipped", "reason" => "not_requested"}, []} =
+               module.run(%{"id" => "step", "params" => params}, context)
+    end
+  end
+
+  test "videos over the limit are skipped with their length" do
+    context = %{
+      run_input: Map.put(base_input(), "audio_description", @requested),
+      dependency_outputs: %{"inspect_media" => %{"duration" => 601.0, "has_video" => true}}
+    }
+
+    assert {:ok, output, []} = MediaDetectScenesStep.run(%{"id" => "detect_scenes"}, context)
+
+    assert %{
+             "status" => "skipped",
+             "reason" => "video_too_long",
+             "video_duration_seconds" => 601.0,
+             "max_duration_seconds" => 600
+           } = output
+  end
+
+  test "the HLS master marks audio descriptions for assistive technology" do
+    outputs = %{
+      "hls_sd" => %{
+        "step_type" => "media.package_hls_variant",
+        "status" => "ok",
+        "codec" => "h264",
+        "size" => "sd",
+        "playlist_path" => "h264_sd_hls/playlist.m3u8"
+      },
+      "hls_audio" => %{
+        "step_type" => "media.package_hls_audio",
+        "status" => "ok",
+        "audio_tracks" => [
+          %{
+            "id" => "default",
+            "label" => "Original",
+            "language" => "en",
+            "default" => true,
+            "hls_playlist" => "audio_hls/playlist.m3u8"
+          }
+        ]
+      },
+      "mix_audio_description_nl" => %{
+        "step_type" => "media.mix_audio_description",
+        "status" => "ok",
+        "audio_track" => %{
+          "id" => "audio_description_nl",
+          "label" => "Dutch (audio description)",
+          "language" => "nl",
+          "default" => false,
+          "hls_playlist" => "audio_description_nl_hls/playlist.m3u8",
+          "characteristics" => "public.accessibility.describes-video"
+        }
+      }
+    }
+
+    assert {:ok, %{"key" => key}, _} =
+             MediaBuildHlsMasterStep.run(%{"id" => "hls_master"}, %{
+               run_input: base_input(),
+               dependency_outputs: outputs
+             })
+
+    {:ok, playlist} = Storage.get(@bucket, key, nil)
+
+    assert playlist =~
+             ~s|#EXT-X-MEDIA:TYPE=AUDIO,GROUP-ID="audio",NAME="Dutch (audio description)",LANGUAGE="nl",DEFAULT=NO,AUTOSELECT=YES,CHARACTERISTICS="public.accessibility.describes-video",CHANNELS="2",URI="audio_description_nl_hls/playlist.m3u8"|
+
+    assert playlist =~ ~s(NAME="Original",LANGUAGE="en",DEFAULT=YES,AUTOSELECT=YES,CHANNELS="2")
+  end
+
+  test "speech retries reuse unchanged cues but regenerate changed text" do
+    key = "#{@embed}/audio_description/en/cues.json"
+    step = %{"id" => "speak_descriptions_en", "params" => %{"language" => "en"}}
+
+    context = %{
+      run_input: Map.put(base_input(), "audio_description", @requested),
+      dependency_outputs: %{
+        "describe_video" => %{
+          "status" => "ok",
+          "cues_key" => key,
+          "speech_key" => "speech.json",
+          "duration" => 8
+        }
+      }
+    }
+
+    put_cue = fn text ->
+      Storage.put(
+        @bucket,
+        key,
+        Jason.encode!([%{"start" => 0, "end" => 1, "text" => text}]),
+        "application/json",
+        nil
+      )
+    end
+
+    put_cue.("A red screen.")
+    assert {:ok, first, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert_received {:speak, "en"}
+    assert {:ok, retry, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert retry["clips"] == first["clips"]
+    refute_received {:speak, "en"}
+
+    put_cue.("A blue screen.")
+    assert {:ok, changed, []} = AiSpeakDescriptionsStep.run(step, context)
+    assert_received {:speak, "en"}
+    refute changed["clips"] == first["clips"]
+  end
+
+  @tag :integration
+  test "original-language preset describes and packages just the detected language" do
+    Process.put(:ad_test_pid, self())
+    {video, audio} = media_fixtures()
+
+    input =
+      Map.merge(base_input(), %{
+        "audio_description" => %{"languages" => ["original"]},
+        "source_body" => video,
+        "source_content_type" => "video/mp4"
+      })
+
+    Storage.put_public(@bucket, "#{@embed}/audio.mp3", audio, "audio/mpeg", nil)
+
+    Storage.put(
+      @bucket,
+      "#{@embed}/subtitle.json",
+      Jason.encode!(%{"segments" => []}),
+      "application/json",
+      nil
+    )
+
+    outputs = %{
+      "source" => %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0},
+      "inspect_media" => %{"duration" => 8.0, "has_video" => true, "has_audio" => true},
+      "transcribe_audio" => %{
+        "status" => "ok",
+        "language" => "nl",
+        "subtitle_json_key" => "#{@embed}/subtitle.json"
+      },
+      "transcode_audio" => %{
+        "status" => "ok",
+        "bucket" => @bucket,
+        "key" => "#{@embed}/audio.mp3",
+        "uri" => "s3://#{@bucket}/#{@embed}/audio.mp3"
+      }
+    }
+
+    {:ok, preset} = Presets.fetch("publish_local")
+
+    steps =
+      Enum.filter(
+        preset["definition"]["steps"],
+        &(&1["id"] in ~w(detect_scenes describe_video speak_descriptions_original mix_audio_description_original))
+      )
+
+    outputs =
+      Enum.reduce(steps, outputs, fn step, acc ->
+        assert {:ok, %{"status" => "ok"} = output, _artifacts} =
+                 Map.fetch!(
+                   %{
+                     "media.detect_scenes" => MediaDetectScenesStep,
+                     "ai.describe_video" => AiDescribeVideoStep,
+                     "ai.speak_descriptions" => AiSpeakDescriptionsStep,
+                     "media.mix_audio_description" => MediaMixAudioDescriptionStep
+                   },
+                   step["type"]
+                 ).run(step, %{run_input: input, dependency_outputs: acc})
+
+        Map.put(acc, step["id"], output)
+      end)
+
+    assert outputs["describe_video"]["language"] == "nl"
+    assert outputs["speak_descriptions_original"]["language"] == "nl"
+    assert outputs["mix_audio_description_original"]["audio_description"]["language"] == "nl"
+    assert_received {:chat, instruction, _}
+    assert instruction =~ "Dutch (nl)"
+    assert_received {:speak, "nl"}
+    refute_received {:speak, "en"}
+    assert {:ok, _} = Storage.get(@bucket, "#{@embed}/audio_description_nl.mp3", nil)
+    assert {:error, _} = Storage.get(@bucket, "#{@embed}/audio_description_en.mp3", nil)
+  end
+
+  @tag :integration
+  test "turns a video into a ducked full mix and descriptions VTT per language" do
+    if System.find_executable("ffmpeg") == nil, do: flunk("ffmpeg is required")
+    Process.put(:ad_test_pid, self())
+
+    {video, audio} = media_fixtures()
+    input = Map.put(base_input(), "audio_description", @requested)
+    Storage.put_public(@bucket, "#{@embed}/audio.mp3", audio, "audio/mpeg", nil)
+
+    transcript = %{
+      "segments" => [%{"start" => 1.0, "end" => 3.0}, %{"start" => 4.5, "end" => 7.5}]
+    }
+
+    Storage.put_public(
+      @bucket,
+      "#{@embed}/subtitle.json",
+      Jason.encode!(transcript),
+      "application/json",
+      nil
+    )
+
+    base_outputs = %{
+      "source" => %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0},
+      "inspect_media" => %{"duration" => 8.0, "has_video" => true, "has_audio" => true},
+      "transcribe_audio" => %{"status" => "ok", "subtitle_json_key" => "#{@embed}/subtitle.json"},
+      "transcode_audio" => %{
+        "status" => "ok",
+        "bucket" => @bucket,
+        "key" => "#{@embed}/audio.mp3",
+        "uri" => "s3://#{@bucket}/#{@embed}/audio.mp3"
+      }
+    }
+
+    # 1. Scenes and stills from the video itself.
+    assert {:ok, scenes, []} =
+             MediaDetectScenesStep.run(%{"id" => "detect_scenes"}, %{
+               run_input:
+                 Map.merge(input, %{"source_body" => video, "source_content_type" => "video/mp4"}),
+               dependency_outputs: base_outputs
+             })
+
+    assert %{"status" => "ok", "scene_count" => 2, "still_count" => 2, "cut_count" => 1} = scenes
+
+    # 2. English cues, pinned to their scenes around the measured speech.
+    outputs = Map.put(base_outputs, "detect_scenes", scenes)
+
+    assert {:ok, english, []} =
+             AiDescribeVideoStep.run(%{"id" => "describe_video"}, %{
+               run_input: input,
+               dependency_outputs: outputs
+             })
+
+    assert %{"status" => "ok", "cue_count" => 2, "language" => "en"} = english
+    assert_received {:chat, system, _content}
+    assert system =~ "S1: 4."
+    assert system =~ "Speech (seconds): 0.85-3.15, 4.35-7.65"
+
+    # 3. Dutch from the English cues.
+    outputs = Map.put(outputs, "describe_video", english)
+
+    assert {:ok, dutch, []} =
+             AiTranslateDescriptionsStep.run(
+               %{"id" => "translate_descriptions_nl", "params" => %{"language" => "nl"}},
+               %{run_input: input, dependency_outputs: outputs}
+             )
+
+    assert %{"status" => "ok", "language" => "nl", "cue_count" => 2} = dutch
+
+    # 4. Speech per language, then the mix.
+    outputs = Map.put(outputs, "translate_descriptions_nl", dutch)
+
+    for {language, cues_step} <- [{"en", "describe_video"}, {"nl", "translate_descriptions_nl"}] do
+      assert {:ok, speech, []} =
+               AiSpeakDescriptionsStep.run(
+                 %{
+                   "id" => "speak_descriptions_#{language}",
+                   "params" => %{"language" => language, "source_step_id" => cues_step}
+                 },
+                 %{run_input: input, dependency_outputs: outputs}
+               )
+
+      assert %{"status" => "ok", "clips" => [_, _]} = speech
+
+      assert {:ok, mix, [mp3_artifact, vtt_artifact]} =
+               MediaMixAudioDescriptionStep.run(
+                 %{
+                   "id" => "mix_audio_description_#{language}",
+                   "params" => %{"language" => language}
+                 },
+                 %{
+                   run_input: input,
+                   dependency_outputs: Map.put(outputs, "speak_descriptions_#{language}", speech)
+                 }
+               )
+
+      assert %{"status" => "ok", "cue_count" => 2, "ducked_cue_count" => 2} = mix
+      assert mix["audio_track"]["characteristics"] == "public.accessibility.describes-video"
+
+      assert mix["audio_track"]["hls_playlist"] ==
+               "audio_description_#{language}_hls/playlist.m3u8"
+
+      assert mp3_artifact.uri == "s3://#{@bucket}/#{@embed}/audio_description_#{language}.mp3"
+      assert vtt_artifact.uri == "s3://#{@bucket}/#{@embed}/descriptions_#{language}.vtt"
+
+      {:ok, mp3} = Storage.get(@bucket, "#{@embed}/audio_description_#{language}.mp3", nil)
+      assert Storage.public?(@bucket, "#{@embed}/audio_description_#{language}.mp3", nil)
+      assert duration(mp3) > 7.5
+
+      {:ok, vtt} = Storage.get(@bucket, "#{@embed}/descriptions_#{language}.vtt", nil)
+      assert vtt =~ "WEBVTT\nKind: descriptions\nLanguage: #{language}\n"
+      assert vtt =~ if(language == "nl", do: "NL A red screen.", else: "A red screen.")
+
+      assert {:ok, _} =
+               Storage.get(
+                 @bucket,
+                 "#{@embed}/audio_description_#{language}_hls/playlist.m3u8",
+                 nil
+               )
+    end
+
+    # A retry reuses the clips it already spoke.
+    assert_received {:speak, "en"}
+
+    {:ok, _, []} =
+      AiSpeakDescriptionsStep.run(
+        %{"id" => "speak_descriptions_en", "params" => %{"language" => "en"}},
+        %{run_input: input, dependency_outputs: outputs}
+      )
+
+    flush_speak()
+    refute_received {:speak, _}
+  end
+
+  defp flush_speak do
+    receive do
+      {:speak, _} -> flush_speak()
+    after
+      0 -> :ok
+    end
+  end
+
+  # An 8 s video that cuts from red to blue at 4 s, with a tone, and its audio as MP3.
+  defp media_fixtures do
+    dir = Path.join(System.tmp_dir!(), "ad-fixture-#{System.unique_integer([:positive])}")
+    File.mkdir_p!(dir)
+    on_exit(fn -> File.rm_rf(dir) end)
+    video = Path.join(dir, "video.mp4")
+    audio = Path.join(dir, "audio.mp3")
+
+    {_, 0} =
+      System.cmd("ffmpeg", [
+        "-v",
+        "error",
+        "-y",
+        "-f",
+        "lavfi",
+        "-i",
+        "color=c=red:s=320x240:d=4:r=25",
+        "-f",
+        "lavfi",
+        "-i",
+        "color=c=blue:s=320x240:d=4:r=25",
+        "-f",
+        "lavfi",
+        "-i",
+        "sine=frequency=330:duration=8",
+        "-filter_complex",
+        "[0:v][1:v]concat=n=2:v=1:a=0[v]",
+        "-map",
+        "[v]",
+        "-map",
+        "2:a",
+        "-c:v",
+        "libx264",
+        "-pix_fmt",
+        "yuv420p",
+        "-c:a",
+        "aac",
+        video
+      ])
+
+    {_, 0} =
+      System.cmd("ffmpeg", ["-v", "error", "-y", "-i", video, "-vn", "-c:a", "libmp3lame", audio])
+
+    {File.read!(video), File.read!(audio)}
+  end
+
+  defp duration(mp3) do
+    path = Path.join(System.tmp_dir!(), "ad-check-#{System.unique_integer([:positive])}.mp3")
+    File.write!(path, mp3)
+
+    {out, 0} =
+      System.cmd("ffprobe", [
+        "-v",
+        "error",
+        "-show_entries",
+        "format=duration",
+        "-of",
+        "csv=p=0",
+        path
+      ])
+
+    File.rm(path)
+    out |> String.trim() |> String.to_float()
+  end
+
+  defp base_input do
+    %{"space_hash" => @space, "embed_hash" => @embed, "version" => 0, "region" => nil}
+  end
+
+  defp restore(key, nil), do: Application.delete_env(:mave_core, key)
+  defp restore(key, value), do: Application.put_env(:mave_core, key, value)
+end
diff --git a/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs b/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
index 0a8aa9b..4610cd8 100644
--- a/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
+++ b/test/mave_core_web/controllers/api/upload/tusd_hooks_controller_test.exs
@@ -4,10 +4,11 @@ defmodule MaveCoreWeb.Api.Upload.TusdHooksControllerTest do
 
   alias MaveCore.Accounts
   alias MaveCore.Assets
-  alias MaveCore.Assets.{Asset, AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Rendition, Subtitle, Video}
   alias MaveCore.Collections.CollectionEmbed
   alias MaveCore.Embeds
   alias MaveCore.Embeds.Embed
+  alias MaveCore.Embeds.ManifestPublisher
   alias MaveCore.Embeds.SettingsSerializer
   alias MaveCore.Flow
   alias MaveCore.Flow.Run
@@ -1463,6 +1464,185 @@ defmodule MaveCoreWeb.Api.Upload.TusdHooksControllerTest do
     end
   end
 
+  @tag :tmp_dir
+  test "audio description uploads support duplicate languages and replacement", %{
+    conn: conn,
+    tmp_dir: tmp_dir
+  } do
+    space = space_fixture()
+    embed = video_embed_fixture(space, %{name: "Uploaded descriptions"})
+    asset = Repo.get!(Asset, embed.asset_id)
+
+    Repo.insert!(%Rendition{
+      video_id: asset.current_video_id,
+      rendition_key: "#{embed.hash}/h264_hd_hls/playlist.m3u8",
+      type: :video,
+      codec: :h264,
+      container: :hls,
+      size: :hd,
+      progress: 100.0
+    })
+
+    path = Path.join(tmp_dir, "description.mp3")
+
+    {_, 0} =
+      System.cmd(
+        "ffmpeg",
+        ["-v", "error", "-y", "-f", "lavfi", "-i", "sine=duration=1", "-c:a", "libmp3lame", path],
+        stderr_to_stdout: true
+      )
+
+    body = File.read!(path)
+
+    upload = fn name, extra ->
+      key = "uploads/#{name}.mp3"
+
+      {:ok, _} =
+        FlowStorageAdapterStub.put("mave-upload", key, body, "audio/mpeg", @upload_source_region)
+
+      response =
+        post(recycle(conn), ~p"/internal/upload-hooks/tusd?secret=hook_secret", %{
+          "Type" => "post-finish",
+          "Event" => %{
+            "Upload" => %{
+              "ID" => name,
+              "Size" => byte_size(body),
+              "MetaData" =>
+                upload_metadata(
+                  embed,
+                  Map.merge(
+                    %{
+                      "custom_audio_track" => "true",
+                      "audio_description" => "true",
+                      "label" => name,
+                      "language" => "en",
+                      "filetype" => "audio/mpeg"
+                    },
+                    extra
+                  )
+                ),
+              "Storage" => %{"Bucket" => "mave-upload", "Key" => key}
+            }
+          }
+        })
+
+      json_response(response, 200)["audio_track_id"]
+    end
+
+    first_id = upload.("first-description", %{})
+    second_id = upload.("second-description", %{})
+    assert first_id != second_id
+    first = Repo.get!(AudioDescription, first_id)
+    assert first.language == "en"
+    assert first.user_managed
+    assert first.vtt_filename == nil
+    assert first.generation_language == nil
+
+    first |> Ecto.Changeset.change(vtt_filename: "old.vtt") |> Repo.update!()
+    assert upload.("replacement", %{"audio_track_id" => first_id, "language" => "nl"}) == first_id
+    replaced = Repo.get!(AudioDescription, first_id)
+    assert replaced.language == "nl"
+    assert replaced.label == "replacement"
+    assert replaced.vtt_filename == nil
+    {:ok, manifest} = ManifestPublisher.current(embed)
+
+    assert Enum.any?(
+             manifest["audio_descriptions"],
+             &(&1["label"] == "replacement (audio description)")
+           )
+
+    {:ok, playlist} =
+      FlowStorageAdapterStub.get(
+        "space-#{space.hash}",
+        "#{embed.hash}/playlist.m3u8",
+        space.region
+      )
+
+    assert playlist =~ "public.accessibility.describes-video"
+
+    vtt = "WEBVTT\n\n00:00:00.000 --> 00:00:01.000\nA blue square appears.\n"
+
+    {:ok, _} =
+      FlowStorageAdapterStub.put(
+        "mave-upload",
+        "description.vtt",
+        vtt,
+        "text/vtt",
+        @upload_source_region
+      )
+
+    response =
+      post(recycle(conn), ~p"/internal/upload-hooks/tusd?secret=hook_secret", %{
+        "Type" => "post-finish",
+        "Event" => %{
+          "Upload" => %{
+            "ID" => "description-vtt",
+            "Size" => byte_size(vtt),
+            "MetaData" =>
+              upload_metadata(embed, %{
+                "custom_subtitle" => "true",
+                "audio_description" => "true",
+                "subtitle_id" => first_id,
+                "filetype" => "text/vtt"
+              }),
+            "Storage" => %{"Bucket" => "mave-upload", "Key" => "description.vtt"}
+          }
+        }
+      })
+
+    assert json_response(response, 200)["subtitle_id"] == first_id
+    with_vtt = Repo.get!(AudioDescription, first_id)
+    assert with_vtt.vtt_file_size == byte_size(vtt)
+
+    assert {:ok, ^vtt} =
+             FlowStorageAdapterStub.get(
+               "space-#{space.hash}",
+               "#{embed.hash}/#{with_vtt.vtt_filename}",
+               space.region
+             )
+
+    assert {:ok, replaced_vtt} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               embed,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "description.vtt"
+             )
+
+    refute replaced_vtt.vtt_filename == with_vtt.vtt_filename
+
+    {:ok, _} =
+      FlowStorageAdapterStub.put(
+        "mave-upload",
+        "invalid.vtt",
+        "not VTT",
+        "text/vtt",
+        @upload_source_region
+      )
+
+    assert {:error, :invalid_vtt} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               embed,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "invalid.vtt"
+             )
+
+    other = video_embed_fixture(space, %{name: "Other description video"})
+
+    assert {:error, :audio_description_not_found} =
+             Assets.ingest_uploaded_audio_description_vtt(
+               other,
+               %{"subtitle_id" => first_id},
+               "mave-upload",
+               "description.vtt"
+             )
+
+    assert {:ok, _} = Assets.delete_audio_description_outputs(embed, first_id)
+    assert Repo.get!(AudioDescription, first_id).deleted_at
+    assert Assets.get_audio_description_for_embed(first_id, embed) == nil
+  end
+
   test "custom audio track uploads create an audio track and package hls audio", %{conn: conn} do
     ffmpeg_bin = System.find_executable("ffmpeg")
 
diff --git a/test/mave_core_web/live/dashboard/data/index_test.exs b/test/mave_core_web/live/dashboard/data/index_test.exs
index 75fcedc..c563a71 100644
--- a/test/mave_core_web/live/dashboard/data/index_test.exs
+++ b/test/mave_core_web/live/dashboard/data/index_test.exs
@@ -22,24 +22,38 @@ defmodule MaveCoreWeb.Live.Dashboard.Data.IndexTest do
 
   test "/data renders space analytics from clickhouse", %{conn: conn, db_name: db_name} do
     {conn, space} = authenticated_conn(conn)
+    now = DateTime.utc_now()
+
+    timestamps = [
+      DateTime.add(now, -172_800, :second),
+      DateTime.add(now, -172_797, :second),
+      DateTime.add(now, -30, :second),
+      DateTime.add(now, -28, :second)
+    ]
 
     sql = """
     INSERT INTO #{db_name}.events
     (timestamp, name, session_id, space_hash, embed_hash, video_time, duration, source_url, browser, browser_version, os, os_version, device, device_brand)
     VALUES
-    (addSeconds(now64(6), -172800), 'play',  '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 0.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
-    (addSeconds(now64(6), -172797), 'pause', '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 3.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
-    (addSeconds(now64(6), -30), 'play',  '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 0.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple'),
-    (addSeconds(now64(6), -28), 'pause', '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 2.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple')
+    ({$0:DateTime64(6)}, 'play',  '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 0.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
+    ({$1:DateTime64(6)}, 'pause', '00000000-0000-0000-0000-000000001002', '#{space.hash}', 'BBBBBBBBBB', 3.0, 10, 'https://example.com/2daysago', 'Safari', '17', 'Mac', '14', 'Mobile', 'Apple'),
+    ({$2:DateTime64(6)}, 'play',  '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 0.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple'),
+    ({$3:DateTime64(6)}, 'pause', '00000000-0000-0000-0000-000000001003', '#{space.hash}', 'CCCCCCCCCC', 2.0, 10, 'https://example.com/today', 'Chrome', '100', 'Mac', '14', 'Desktop', 'Apple')
     """
 
-    {:ok, _} = ClickHouseRepo.query(sql)
+    {:ok, _} = ClickHouseRepo.query(sql, timestamps)
     ClickHouseRepo.query("OPTIMIZE TABLE #{db_name}.events FINAL")
 
     {:ok, view, _html} = live(conn, "/data")
     # Real ClickHouse queries can exceed the default 100 ms on a cold test stack.
     _ = render_async(view, 5_000)
     html = render(view)
+    month_start = Date.beginning_of_month(Date.utc_today())
+
+    expected_views =
+      timestamps
+      |> Enum.take_every(2)
+      |> Enum.count(&(Date.compare(DateTime.to_date(&1), month_start) != :lt))
 
     assert html =~ "Views"
     assert html =~ "Watch time"
@@ -50,10 +64,12 @@ defmodule MaveCoreWeb.Live.Dashboard.Data.IndexTest do
     assert html =~ "Device"
     assert html =~ "Browser"
     assert has_element?(view, "#data-trend .w-1")
-    assert has_element?(view, "#data-trend .bg-blue-500")
+    if expected_views > 0, do: assert(has_element?(view, "#data-trend .bg-blue-500"))
     refute has_element?(view, "#data-trend svg")
-    # The default calendar month includes both views.
-    assert view |> element("#data-kpis") |> render() =~ ~r/>\s*2\s*</
+    # Two days ago may belong to the previous calendar month.
+    assert view |> element("#data-kpis > div:first-child") |> render() =~
+             ~r/>\s*#{expected_views}\s*</
+
     refute html =~ "font-family: 'Sofia'"
   end
 
diff --git a/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs b/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs
new file mode 100644
index 0000000..b9c5145
--- /dev/null
+++ b/test/mave_core_web/live/dashboard/settings/audio_description_setting_test.exs
@@ -0,0 +1,80 @@
+defmodule MaveCoreWeb.Live.Dashboard.Settings.AudioDescriptionSettingTest do
+  use MaveCoreWeb.ConnCase, async: false
+
+  import Phoenix.LiveViewTest
+
+  alias MaveCore.Accounts
+  alias MaveCore.Repo
+  alias MaveCore.Spaces.Space
+
+  defmodule PaidOnly do
+    @behaviour MaveCore.UsageLimits
+
+    def can_create_video_embed?(_space), do: :ok
+    def can_add_space_member?(_space, _role), do: :ok
+    def can_use_audio_description?(_space), do: {:error, :paid_plan_required}
+
+    def restriction_copy(:audio_description, :paid_plan_required),
+      do: %{notice: "Available on paid plans", error: "Upgrade to use audio description."}
+
+    def restriction_copy(_operation, _reason), do: %{}
+  end
+
+  setup do
+    old_backend = Application.get_env(:mave_core, :usage_limits_backend)
+
+    on_exit(fn ->
+      if old_backend,
+        do: Application.put_env(:mave_core, :usage_limits_backend, old_backend),
+        else: Application.delete_env(:mave_core, :usage_limits_backend)
+    end)
+
+    :ok
+  end
+
+  test "toggles audio description for the space", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    {:ok, view, _html} = live(conn, "/settings")
+
+    assert has_element?(view, "#audio-description-feature")
+    refute has_element?(view, "#audio-description-notice")
+
+    view |> element("#audio-description-toggle") |> render_click()
+    assert Repo.get!(Space, space.id).audio_description_enabled
+
+    view |> element("#audio-description-toggle") |> render_click()
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  test "shows the host's notice and keeps the toggle off when not allowed", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    Application.put_env(:mave_core, :usage_limits_backend, PaidOnly)
+    {:ok, view, html} = live(conn, "/settings")
+
+    assert html =~ "Available on paid plans"
+    assert has_element?(view, "#audio-description-toggle.pointer-events-none")
+    refute Repo.get!(Space, space.id).audio_description_enabled
+  end
+
+  defp authenticated_conn(conn) do
+    email = "ad-settings-#{System.unique_integer([:positive])}@example.com"
+    {:ok, user} = Accounts.create_user(email)
+    login_token = Accounts.generate_user_login_token(user)
+    {:ok, {logged_in_user, persisted_login_token}} = Accounts.login_user(login_token)
+    session_token = Accounts.generate_user_session_token(persisted_login_token, logged_in_user)
+
+    conn =
+      conn
+      |> with_manage_host()
+      |> init_test_session(user_token: session_token)
+
+    {conn, logged_in_user.current_space_membership.space}
+  end
+
+  defp with_manage_host(conn) do
+    case System.get_env("MAVE_MANAGE_HOST") do
+      host when is_binary(host) and host != "" -> %{conn | host: host}
+      _ -> conn
+    end
+  end
+end
diff --git a/test/mave_core_web/live/dashboard/videos/show_test.exs b/test/mave_core_web/live/dashboard/videos/show_test.exs
index d6c0a01..2181a1d 100644
--- a/test/mave_core_web/live/dashboard/videos/show_test.exs
+++ b/test/mave_core_web/live/dashboard/videos/show_test.exs
@@ -5,7 +5,7 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
   import Phoenix.LiveViewTest
 
   alias MaveCore.Accounts
-  alias MaveCore.Assets.{Asset, AudioTrack, Subtitle, Video}
+  alias MaveCore.Assets.{Asset, AudioDescription, AudioTrack, Subtitle, Video}
   alias MaveCore.ClickHouseRepo
   alias MaveCore.Collections.{Collection, CollectionEmbed}
   alias MaveCore.Embeds.{Embed, SettingsSerializer}
@@ -1624,6 +1624,101 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
     stop_live_view(reloaded_view)
   end
 
+  test "audio descriptions have their own editable settings and appear under Audio in Info", %{
+    conn: conn
+  } do
+    {conn, space} = authenticated_conn(conn)
+
+    embed =
+      video_embed_fixture(space, %{name: "Description management"})
+      |> Repo.preload(asset: [:current_video])
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: embed.asset.current_video_id,
+        language: "nl",
+        generation_language: "nl",
+        audio_filename: "description.mp3",
+        vtt_filename: "description.vtt"
+      })
+
+    {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+    assert has_element?(view, "#audio-description-settings")
+    refute render(view) =~ "Upload a full audio mix"
+    assert has_element?(view, "#audio-description-settings [phx-click=add_audio_description]")
+    assert has_element?(view, "#audio-description-replace-#{description.id}[aria-haspopup=menu]")
+
+    assert has_element?(
+             view,
+             "#audio-description-files-#{description.id} [role=menuitem]",
+             "Replace text"
+           )
+
+    render_click(element(view, "#audio-description-replace-audio-#{description.id}"))
+    assert has_element?(view, "input[type=file][accept='.mp3']")
+
+    render_click(element(view, "#audio-description-vtt-#{description.id}"))
+    assert has_element?(view, "input[type=file][accept='.vtt']")
+    assert has_element?(view, "#delete-audio-description-#{description.id}")
+
+    view
+    |> element("#audio-description-settings input[name='audio_track[label]']")
+    |> render_blur(%{"id" => description.id, "value" => "Dutch accessible audio"})
+
+    assert Repo.get!(AudioDescription, description.id).label == "Dutch accessible audio"
+
+    view
+    |> element("#audio-description-language-form-#{description.id}")
+    |> render_change(%{"audio_track" => %{"language" => "en"}})
+
+    assert Repo.get!(AudioDescription, description.id).language == "en"
+
+    render_click(element(view, "[phx-value-tab=info]"))
+    assert has_element?(view, "#rendition-group-audio", "Dutch accessible audio (AD)")
+    assert has_element?(view, "#rendition-group-audio", "HLS")
+    assert has_element?(view, "#rendition-group-audio", "MP3")
+    assert has_element?(view, "#rendition-group-audio", "VTT")
+    refute has_element?(view, "#audio-descriptions")
+    refute has_element?(view, "#rendition-group-audio a")
+
+    render_click(element(view, "[phx-value-tab=options]"))
+    render_click(element(view, "#delete-audio-description-#{description.id}"))
+    assert Repo.get!(AudioDescription, description.id).deleted_at == nil
+    assert has_element?(view, "#delete-media-dialog", "Dutch accessible audio")
+    render_click(element(view, "#delete-media-dialog-confirm"))
+    assert Repo.get!(AudioDescription, description.id).deleted_at
+    refute has_element?(view, "#delete-audio-description-#{description.id}")
+    stop_live_view(view)
+  end
+
+  test "audio description settings ignore changes to another video's description", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+    embed = video_embed_fixture(space, %{name: "Description scope"})
+
+    other =
+      video_embed_fixture(space, %{name: "Other video"}) |> Repo.preload(asset: [:current_video])
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: other.asset.current_video_id,
+        language: "en",
+        audio_filename: "other.mp3"
+      })
+
+    {:ok, view, _html} = live(conn, "/videos/#{embed.id}")
+    target = with_target(view, "#video-settings")
+
+    render_hook(target, "blur_audio_description_label", %{
+      "id" => description.id,
+      "value" => "Changed"
+    })
+
+    render_hook(target, "delete_audio_description", %{"id" => description.id})
+    assert Repo.get!(AudioDescription, description.id).label == nil
+    assert Repo.get!(AudioDescription, description.id).deleted_at == nil
+    stop_live_view(view)
+  end
+
   test "/videos/:id renders an empty audio tracks state when there are no tracks", %{conn: conn} do
     {conn, space} = authenticated_conn(conn)
     video = video_embed_fixture(space, %{name: "Audio Track Settings"})
@@ -1653,13 +1748,22 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
       })
       |> Repo.insert!()
 
-    {:ok, _view, html} = live(conn, "/videos/#{video.id}")
+    {:ok, view, html} = live(conn, "/videos/#{video.id}")
+
+    render_click(element(view, "#delete-audio-track-#{track.id}"))
+    assert Repo.get(AudioTrack, track.id)
+    render_click(element(view, "#delete-media-dialog button", "cancel"))
+    assert Repo.get(AudioTrack, track.id)
+    refute has_element?(view, "#delete-media-dialog")
+    render_click(element(view, "#delete-audio-track-#{track.id}"))
+    render_click(element(view, "#delete-media-dialog-confirm"))
+    refute Repo.get(AudioTrack, track.id)
 
     assert html =~ "audio tracks"
     assert html =~ "Commentary"
     assert html =~ ~s(id="delete-audio-track-#{track.id}")
-    assert html =~ "Remove audio track"
-    assert html =~ "phx-click-loading:inline-flex"
+    assert html =~ "Delete"
+    assert html =~ "file_menu"
   end
 
   test "/videos/:id saves audio track label on blur", %{conn: conn} do
@@ -1691,8 +1795,13 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
       "value" => "Director Commentary"
     })
 
+    view
+    |> element("#audio-track-language-form-#{track.id}")
+    |> render_change(%{"audio_track" => %{"language" => "nl"}})
+
     stop_live_view(view)
     assert Repo.get!(AudioTrack, track.id).label == "Director Commentary"
+    assert Repo.get!(AudioTrack, track.id).language == "nl"
   end
 
   test "/videos/:id ignores audio track mutations from another space", %{conn: conn} do
@@ -1858,8 +1967,73 @@ defmodule MaveCoreWeb.Live.Dashboard.Videos.ShowTest do
     assert has_element?(view, ~s(a[href="#{subtitle_download_path}"][download="en.vtt"]))
     refute has_element?(view, ~s(a[href="#{subtitle_download_path}"][target]))
     assert html =~ ~s(id="delete-subtitle-#{subtitle.id}")
-    assert html =~ "Remove subtitle"
-    assert html =~ "phx-click-loading:inline-flex"
+    assert html =~ "Delete"
+    assert html =~ "file_menu"
+  end
+
+  test "audio downloads are attachments scoped to the current video", %{conn: conn} do
+    {conn, space} = authenticated_conn(conn)
+
+    embed =
+      video_embed_fixture(space, %{name: "Audio downloads"})
+      |> Repo.preload(asset: [:current_video])
+
+    other = video_embed_fixture(space, %{name: "Other video"})
+
+    track =
+      Repo.insert!(%AudioTrack{
+        video_id: embed.asset.current_video_id,
+        label: "Original",
+        filename: "audio.mp3",
+        codec: "mp3"
+      })
+
+    description =
+      Repo.insert!(%AudioDescription{
+        video_id: embed.asset.current_video_id,
+        label: "Accessible",
+        language: "en",
+        audio_filename: "ad.mp3",
+        vtt_filename: "ad.vtt"
+      })
+
+    bucket = Storage.bucket_for_space(space.hash, space.region)
+
+    for {file, body, type} <- [
+          {"audio.mp3", "audio bytes", "audio/mpeg"},
+          {"ad.mp3", "description bytes", "audio/mpeg"},
+          {"ad.vtt", "WEBVTT\n", "text/vtt"}
+        ] do
+      {:ok, _} =
+        FlowStorageAdapterStub.put_public(
+          bucket,
+          "#{embed.hash}/#{file}",
+          body,
+          type,
+          space.region
+        )
+    end
+
+    for {suffix, body} <- [
+          {"audio-tracks/#{track.id}/download", "audio bytes"},
+          {"audio-descriptions/#{description.id}/mp3/download", "description bytes"},
+          {"audio-descriptions/#{description.id}/vtt/download", "WEBVTT\n"}
+        ] do
+      downloaded = get(conn, "/#{space.id}/videos/#{embed.id}/#{suffix}")
+      assert response(downloaded, 200) == body
+      assert hd(get_resp_header(downloaded, "content-disposition")) =~ "attachment"
+      assert response(get(conn, "/#{space.id}/videos/#{other.id}/#{suffix}"), 404)
+    end
+
+    description |> Ecto.Changeset.change(deleted_at: DateTime.utc_now()) |> Repo.update!()
+
+    assert response(
+             get(
+               conn,
+               "/#{space.id}/videos/#{embed.id}/audio-descriptions/#{description.id}/mp3/download"
+             ),
+             404
+           )
   end
 
   test "/videos/:id subtitle download returns VTT as an attachment", %{conn: conn} do