# Workflows

Detailed documentation for each pre-built workflow.

## What are Workflows?

Workflows are production-ready functions that orchestrate complete video AI tasks from start to finish. Each workflow handles the entire process: fetching video data from Mux (transcripts, storyboards, thumbnails), formatting it appropriately for AI providers, making the AI call with optimized prompts, and returning structured, typed results.

For audio-only assets (no video track), see [Audio-Only Workflows](./AUDIO-ONLY.md).

Internally, every workflow is composed from [primitives](./PRIMITIVES.md) - the low-level building blocks that provide direct access to Mux video data. This layered architecture means you can start with workflows for common tasks, and when you need more control, drop down to primitives to build custom solutions. Think of workflows as the "batteries included" layer and primitives as the foundation you can build on.

Workflows in this project are exported with the `"use workflow"` directive, which makes them compatible with [Workflow DevKit](https://useworkflow.dev). See the [Workflow DevKit guide](./WORKFLOW-DEVKIT.md) for integration details.

## Video Summarization

Generate AI-powered titles, descriptions, and tags from video content.

```typescript
import { getSummaryAndTags } from "@mux/ai/workflows";

const result = await getSummaryAndTags("your-mux-asset-id", {
  provider: "anthropic",
  tone: "professional"
});

console.log(result.title); // Short, descriptive title
console.log(result.description); // Detailed description
console.log(result.tags); // Array of relevant keywords
```

### Image Submission Modes

Choose between two methods for submitting images to AI providers:

**URL Mode (Default):**

- Fast initial response
- Lower bandwidth usage
- Relies on AI provider's image downloading
- May encounter timeouts with slow/unreliable image sources

**Base64 Mode (Recommended for Production):**

- Downloads images locally with robust retry logic
- Eliminates AI provider timeout issues
- Better control over slow TTFB and network issues
- Slightly higher bandwidth usage but more reliable results
- For OpenAI: submits images as base64 data URIs
- For Anthropic/Google: the AI SDK handles converting the base64 payload into the provider-specific format automatically

```typescript
// High reliability mode - recommended for production
const result = await getSummaryAndTags(assetId, {
  imageSubmissionMode: "base64",
  imageDownloadOptions: {
    timeout: 15000, // 15s timeout per image
    retries: 3, // Retry failed downloads 3x
    retryDelay: 1000, // 1s base delay with exponential backoff
    exponentialBackoff: true
  }
});
```

### Custom Prompts

Customize specific sections of the prompt for different use cases:

```typescript
// SEO-optimized metadata
const seoResult = await getSummaryAndTags(assetId, {
  promptOverrides: {
    task: "Generate SEO-optimized metadata for search engines.",
    title: "Create a search-optimized title (50-60 chars) with primary keyword.",
    keywords: "Focus on high search volume and long-tail keywords.",
  },
});
```

See [API Reference](./API.md#custom-prompts-with-promptoverrides) for more examples.

## Content Moderation

Analyze a Mux asset for inappropriate material using OpenAI, Hive, or Google Vision SafeSearch.

- For **video assets**, moderation runs over storyboard thumbnails.
- For **audio-only assets**, moderation runs over transcript text. Only OpenAI supports this — Hive and Google Vision are image-only.

```typescript
import { getModerationScores } from "@mux/ai/workflows";

// Analyze with OpenAI (default)
const result = await getModerationScores("your-mux-asset-id", {
  thresholds: { sexual: 0.7, violence: 0.8 }
});

console.log(result.maxScores); // Highest scores across all thumbnails (or transcript for audio-only)
console.log(result.exceedsThreshold); // true if content should be flagged
console.log(result.coverage); // sample coverage and low-confidence metadata

// Use Hive for visual moderation
const hiveResult = await getModerationScores("your-mux-asset-id", {
  provider: "hive",
  thresholds: { sexual: 0.9, violence: 0.9 },
});

// Use Google Vision SafeSearch
const visionResult = await getModerationScores("your-mux-asset-id", {
  provider: "google-vision-api",
});
```

### Provider Comparison

- **OpenAI**: Uses the `omni-moderation-latest` model with dedicated moderation API. Supports text moderation for audio-only assets.
- **Hive**: Visual moderation by default; audio-only/text moderation requires a Hive **Text Moderation** project/API key (otherwise Hive will reject `text_data`) — see [Hive Text Moderation docs](https://docs.thehive.ai/docs/classification-text)
- **Google Vision API**: SafeSearch detection. Image-only — audio-only assets throw a clear error. SafeSearch returns discrete `Likelihood` buckets (`UNKNOWN`..`VERY_LIKELY`) which are linearly mapped onto 0..1 (so `LIKELY` ≈ 0.8, `VERY_LIKELY` = 1.0). Only `adult` and `violence` likelihoods are surfaced; `racy`, `spoof`, and `medical` are ignored. We've observed some instability in the `adult` measurement that can produce false positives, so you may want to tune your `sexual` threshold up when using Google Vision.

## Burned-in Caption Detection

Detect hardcoded subtitles permanently embedded in video frames.

```typescript
import { hasBurnedInCaptions } from "@mux/ai/workflows";

const result = await hasBurnedInCaptions("your-mux-asset-id", {
  provider: "openai"
});

console.log(result.hasBurnedInCaptions); // true/false
console.log(result.confidence); // 0.0-1.0 confidence score
console.log(result.detectedLanguage); // Language if captions detected
```

### Detection Logic

- Analyzes video storyboard frames to identify text overlays
- Distinguishes between actual captions and marketing/end-card text
- Text appearing only in final 1-2 frames is classified as marketing copy
- Caption text must appear across multiple frames throughout the timeline
- Optimized prompts minimize false positives

## Ask Questions

Answer questions about asset content by analyzing storyboard frames and optional transcripts. For audio-only assets, this workflow analyzes transcript text only. By default, answers are "yes"/"no", but you can specify different allowed answers per question.

```typescript
import { askQuestions } from "@mux/ai/workflows";

// Single question
const result = await askQuestions("your-mux-asset-id", [
  { question: "Does this video contain cooking?" }
], {
  provider: "openai"
});

console.log(result.answers[0].answer); // "yes" or "no" by default
console.log(result.answers[0].confidence); // 0.0-1.0 confidence score
console.log(result.answers[0].reasoning); // AI's explanation
```

### Multiple Questions

Process multiple questions in a single API call for efficiency:

```typescript
const result = await askQuestions(assetId, [
  { question: "Does this video contain people?" },
  { question: "Is this video in color?" },
  { question: "Does this video contain violence?" },
  { question: "Is this suitable for children?" }
]);

// Process all answers
result.answers.forEach(answer => {
  console.log(`Q: ${answer.question}`);
  console.log(`A: ${answer.answer} (${Math.round(answer.confidence * 100)}% confident)`);
  console.log(`Reasoning: ${answer.reasoning}\n`);
});
```

### Use Cases

- **Content Classification:** "Is this a product demo?", "Does this contain advertisements?"
- **Content Moderation:** "Does this show violence?", "Is there inappropriate content?"
- **Quality Checks:** "Is the audio clear?", "Is the lighting professional?"
- **Accessibility Audits:** "Are there visual text elements?", "Does this rely only on audio?"
- **Metadata Validation:** "Does the content match the title?", "Is this in English?"

### Per-question Answer Options

Each question can specify its own allowed answers, so classification scales and enumerations can sit alongside simple yes/no checks in a single call. Questions without `answerOptions` default to `["yes", "no"]`:

```typescript
const result = await askQuestions(assetId, [
  { question: "Does this video contain people?" }, // answer options default to yes/no
  { question: "What is the primary content type?", answerOptions: ["tutorial", "entertainment", "news", "advertisement"] },
  { question: "What is the production quality?", answerOptions: ["amateur", "semi-pro", "professional"] },
  { question: "What is the primary spoken language?", answerOptions: ["english", "spanish", "french", "other"] },
]);
```

### Configuration Options

```typescript
const result = await askQuestions(assetId, questions, {
  provider: "openai", // "openai", "anthropic", or "google" (default: "openai")
  model: "gpt-5.1", // Override default model
  includeTranscript: true, // Include transcript (default: true)
  cleanTranscript: true, // Remove timestamps/markup (default: true)
  imageSubmissionMode: "url", // "url" or "base64" (default: "url")
  storyboardWidth: 640 // Storyboard resolution in pixels (default: 640)
});
```

### Free-form Replies (Experimental)

> ⚠️ **Experimental**
>
> By default, answers are constrained to the values in `answerOptions` (or
> `["yes", "no"]`). Setting `freeFormReply: true` on a question lets the
> model reply with open-ended prose instead. `freeFormReply` and
> `answerOptions` are mutually exclusive — setting both throws a
> validation error.
>
> Use this only when you genuinely need open-ended answers (describing a
> scene, extracting a quoted line, summarising a segment). The
> constrained-enum mode is the safer default — restricting answers to a
> fixed set prevents arbitrary prose on the output channel. Free-form
> answers are still length-capped (`maxFreeFormAnswerLength`, default 500)
> and still pass through the output-safety scrubber.

```typescript
const result = await askQuestions(assetId, [
  { question: "Is this video about glasses?" }, // constrained yes/no
  {
    question: "Describe the primary subject of the video in one sentence.",
    freeFormReply: true,
  },
  {
    question: "What is the primary subject?",
    answerOptions: ["glasses", "watches", "shoes", "hats"],
  }, // constrained enum
], {
  maxFreeFormAnswerLength: 300,
});

console.log(result.answers[1].answer); // e.g. "A pair of tortoiseshell glasses..."
```

### Tips for Effective Questions

- **Be specific:** "Does this show a person cooking in a kitchen?" vs "Does this have food?"
- **Frame positively:** "Is this video in color?" vs "Is this video not black and white?"
- **Avoid ambiguity:** Questions should have clear answers that map to your allowed options
- **Use objective criteria:** Focus on observable evidence rather than subjective opinions

### Transcript Integration

When `includeTranscript` is enabled (default), the AI considers both visual frames and audio/dialogue:

```typescript
// Without transcript - visual analysis only
const visualOnly = await askQuestions(assetId, [
  { question: "Does someone speak in this video?" }
], {
  includeTranscript: false
});

// With transcript - analyzes both visual and audio
const withAudio = await askQuestions(assetId, [
  { question: "Does someone speak in this video?" }
], {
  includeTranscript: true
});
```

The AI will prioritize visual evidence when transcript and visuals conflict.

For audio-only assets, transcript support is required:

```typescript
const audioOnlyResult = await askQuestions(audioOnlyAssetId, [
  { question: "Is there spoken dialogue in this content?" }
], {
  includeTranscript: true
});
```

## Engagement Insights

Generate AI-powered explanations of viewer engagement patterns by analyzing hotspot data, heatmap statistics, visual frames, and transcripts.

```typescript
import { generateEngagementInsights } from "@mux/ai/workflows";

const result = await generateEngagementInsights("your-mux-asset-id", {
  provider: "openai",
  hotspotLimit: 5
});

// Per-moment insights
result.momentInsights.forEach(insight => {
  console.log(`${insight.timestamp}: ${insight.insight}`);
});

// Overall analysis
console.log(result.overallInsight.summary);
console.log("Trends:", result.overallInsight.trends);
```

### Requirements

- Asset must have engagement data (views with re-watch activity)
- Engagement data is pulled from the specified timeframe (default: 7 days)
- For audio-only assets, visual analysis is skipped

### Configuration Options

```typescript
const result = await generateEngagementInsights(assetId, {
  provider: "openai", // "openai", "anthropic", or "google"
  hotspotLimit: 5, // Moments per direction (1-10, default: 5). Up to 2x total.
  timeframe: "7:days", // "1:hour", "24:hours", "7:days", "30:days"
  skipShots: false, // Skip shots polling, use thumbnails (default: false)
});
```

### How It Works

The workflow combines multiple data sources for comprehensive analysis:

1. **Fetches engagement data** - Both peaks (high engagement) and valleys (low engagement) from Mux Data API
2. **Fetches visual context** - Scene-representative frames via shots API (falls back to thumbnails if unavailable)
3. **Fetches heatmap data** - Full engagement curve for context
4. **Analyzes transcript** - Matches transcript segments to engagement moments
5. **Generates AI insights** - Explains patterns based on observable evidence from visuals and transcript

### Output Structure

```typescript
{
  assetId: "abc123",
  momentInsights: [
    {
      startMs: 86922,
      endMs: 90331,
      timestamp: "1:26",
      engagementScore: 0.875, // 0-1 normalized score
      insight: "The cooking demonstration shows...",
    }
  ],
  overallInsight: {
    summary: "This video has strong engagement during...",
    trends: [
      "Engagement peaks during visual demonstrations",
      "Significant 40% drop after intro"
    ],
  },
  usage: {...} // Token usage stats
}
```

### Use Cases

- **Content Optimization**: Identify what works and what doesn't in your videos
- **Audience Analysis**: Understand which content types drive re-watching
- **Pacing Improvements**: Find moments where viewers drop off
- **A/B Testing**: Compare engagement patterns across video variations
- **Creator Insights**: Provide engagement feedback to content creators

### Best Practices

- Use a **7-day timeframe** (default) for stable engagement data
- Increase **timeframe** for newer videos that haven't accumulated views
- Use **`skipShots: true`** for latency-sensitive API endpoints (saves up to 30s)
- Videos need sufficient view data — new or low-view videos may not have engagement data
- Audio-only assets work but lack visual analysis
- The heatmap is 100 data points regardless of video length — each point represents 1/100th of the video

## Chapter Generation

Generate AI-powered chapter markers from video or audio transcripts.

```typescript
import { generateChapters } from "@mux/ai/workflows";

const result = await generateChapters("your-mux-asset-id", {
  provider: "openai"
});

console.log(result.chapters); // Array of {startTime: number, title: string}

// Use with Mux Player
const player = document.querySelector("mux-player");
player.addChapters(result.chapters);
```

### Requirements

- Asset must have a ready caption/transcript track
- When `languageCode` is omitted, prefers an English track if available
- Uses existing auto-generated or uploaded captions/transcripts

## Embeddings

Generate vector embeddings for semantic search over video or audio transcripts.

```typescript
import { generateEmbeddings } from "@mux/ai/workflows";

// Token-based chunking
const result = await generateEmbeddings("your-mux-asset-id", {
  provider: "openai",
  chunkingStrategy: {
    type: "token",
    maxTokens: 500,
    overlap: 100
  }
});

console.log(result.chunks); // Array of chunk embeddings with timestamps
console.log(result.averagedEmbedding); // Single embedding for entire transcript

// Store chunks in vector database for timestamp-accurate search
for (const chunk of result.chunks) {
  await vectorDB.insert({
    id: `${result.assetId}:${chunk.chunkId}`,
    embedding: chunk.embedding,
    startTime: chunk.metadata.startTime,
    endTime: chunk.metadata.endTime
  });
}
```

### Chunking Strategies

**Token-based Chunking:**

- Splits transcript by token count
- Simple overlap between chunks
- Good for general semantic search

**VTT-based Chunking:**

- Respects caption cue boundaries
- Overlap measured in cues
- Better preserves natural speech breaks

```typescript
// VTT-based chunking
const vttResult = await generateEmbeddings("your-mux-asset-id", {
  provider: "google",
  chunkingStrategy: {
    type: "vtt",
    maxTokens: 500,
    overlapCues: 2
  }
});
```

## Caption Translation

Translate existing captions to different languages and add as new tracks (video or audio-only assets).

```typescript
import { translateCaptions } from "@mux/ai/workflows";

// Translate a caption track to Spanish and upload to Mux
const result = await translateCaptions(
  "your-mux-asset-id",
  "your-track-id", // source caption track ID
  "es", // target language
  {
    provider: "google",
    model: "gemini-3-flash-preview"
  }
);

console.log(result.uploadedTrackId); // New Mux track ID
console.log(result.presignedUrl); // S3 file URL
console.log(result.translatedVtt); // Translated VTT content
```

By default, `translateCaptions` uses VTT-aware chunking for longer assets. It prefers a single request for shorter media, then splits larger translations by cue-aligned chunks and rebuilds the final VTT locally.

```typescript
// Override chunking behavior for large assets
const result = await translateCaptions("your-mux-asset-id", "your-track-id", "es", {
  provider: "anthropic",
  chunking: {
    enabled: true,
    minimumAssetDurationSeconds: 20 * 60,
    targetChunkDurationSeconds: 15 * 60,
    maxConcurrentTranslations: 3,
    maxCuesPerChunk: 60,
    maxCueTextTokensPerChunk: 1500,
  },
});
```

Set `chunking.enabled` to `false` if you want to force a single structured translation request for the full caption file.

### S3-Compatible Storage Requirements

Caption translation requires S3-compatible storage to host VTT files for Mux ingestion.

**Supported Providers:**

- **AWS S3** - Amazon's object storage
- **DigitalOcean Spaces** - S3-compatible with CDN
- **Cloudflare R2** - Zero egress fees
- **MinIO** - Self-hosted S3 alternative
- **Backblaze B2** - Cost-effective storage
- **Wasabi** - Hot cloud storage

**Configuration:**

Set environment variables:

```bash
S3_ENDPOINT=https://your-s3-endpoint.com
S3_REGION=auto
S3_BUCKET=your-bucket-name
S3_ACCESS_KEY_ID=your-access-key
S3_SECRET_ACCESS_KEY=your-secret-key
```

`s3Endpoint`, `s3Region` and `s3Bucket` can also be used to override the environment varialbes

```typescript
const result = await translateCaptions(assetId, "your-track-id", "es", {
  provider: "anthropic",
  s3Endpoint: "https://your-endpoint.com",
  s3Region: "auto",
  s3Bucket: "your-bucket",
});
```

> **⚠️ Important:** Workflow Dev Kit serializes workflow inputs/outputs. Do not pass plaintext secrets as workflow args.
> Use the `encryptForWorkflow` helper and pass `credentials` to workflows when running multi-tenant.
> `S3_ACCESS_KEY_ID` and `S3_SECRET_ACCESS_KEY` must still be set as ENV vars on the execution host.


**Why S3 Storage?**

Mux requires a publicly accessible URL to ingest subtitle tracks. The translation workflow:

1. Uploads translated VTT to your S3 storage
2. Generates a presigned URL for secure access
3. Mux fetches the file using the presigned URL
4. File remains in your storage for future use

### Supported Languages

All ISO 639-1 language codes are automatically supported using `Intl.DisplayNames`. Examples: Spanish (es), French (fr), German (de), Italian (it), Portuguese (pt), Polish (pl), Japanese (ja), Korean (ko), Chinese (zh), Russian (ru), Arabic (ar), Hindi (hi), Thai (th), Swahili (sw), and many more.

## Caption Editing

Edit existing captions with LLM-powered profanity censorship, static find/replace, or both. Optionally upload the edited track to Mux.

```typescript
import { editCaptions } from "@mux/ai/workflows";

const result = await editCaptions("your-mux-asset-id", "track-id", {
  provider: "anthropic",
  autoCensorProfanity: { mode: "blank" },
  replacements: [
    { find: "Mucks", replace: "Mux" },
  ],
});

console.log(result.totalReplacementCount); // Total replacements across all operations
console.log(result.autoCensorProfanity?.replacements); // Each censored word with cue timing
console.log(result.editedVtt); // Edited VTT content
console.log(result.uploadedTrackId); // New Mux track ID
```

### Auto-Censor Profanity

LLM-powered profanity detection and censorship. Requires a `provider`.

#### Censor Modes

Choose how profanity is replaced:

| Mode | Example | Description |
| --- | --- | --- |
| `"blank"` (default) | `shit` → `[____]` | Bracketed underscores matching word length |
| `"remove"` | `shit` → *(removed)* | Word removed entirely |
| `"mask"` | `shit` → `????` | Question marks matching word length |

#### Override Lists

Fine-tune what gets censored with `alwaysCensor` and `neverCensor`:

```typescript
const result = await editCaptions(assetId, trackId, {
  provider: "openai",
  autoCensorProfanity: {
    mode: "mask",
    alwaysCensor: ["brandname", "competitor"], // Always censor these, even if LLM doesn't flag them
    neverCensor: ["damn", "hell"], // Never censor these, even if LLM flags them
  },
});
```

`neverCensor` takes precedence when a word appears in both lists.

### Static Replacements

Apply deterministic find/replace pairs without an LLM. No `provider` needed when used alone:

```typescript
const result = await editCaptions(assetId, trackId, {
  replacements: [
    { find: "Mucks", replace: "Mux" },
    { find: "gonna", replace: "going to" },
  ],
});
```

Replacements use word-boundary matching and are case-sensitive by default. Set `caseSensitive: false` on an individual entry to match regardless of case:

```typescript
const result = await editCaptions(assetId, trackId, {
  replacements: [
    { find: "Mucks", replace: "Mux" }, // case-sensitive (default)
    { find: "gonna", replace: "going to", caseSensitive: false }, // matches "Gonna", "GONNA", etc.
  ],
});
```

### Application Order

1. `autoCensorProfanity` applied first (LLM analyses original text, censorship applied to VTT)
2. Static `replacements` applied second (deterministic, operates on the post-censorship VTT)

### How It Works

1. Downloads the VTT caption track from Mux
2. Extracts plain text from the original VTT and sends it to the LLM for profanity detection (if `autoCensorProfanity` is set)
3. The LLM returns a list of profane words (not a rewritten VTT) — this guarantees format preservation
4. Merges `alwaysCensor` and filters `neverCensor` from the detected list
5. Applies profanity censorship to the VTT
6. Applies static replacements (if provided) using word-boundary regex
7. Uploads the edited VTT to S3 and creates a new track on Mux
8. Deletes the original track (configurable)

### S3-Compatible Storage Requirements

Caption editing requires the same S3-compatible storage as [caption translation](#caption-translation) when uploading to Mux. See that section for supported providers and configuration.

### Configuration

```typescript
const result = await editCaptions(assetId, trackId, {
  provider: "anthropic", // Required when using autoCensorProfanity
  model: "claude-sonnet-4-5", // Override default model
  autoCensorProfanity: {
    mode: "blank", // "blank", "remove", or "mask" (default: "blank")
    alwaysCensor: [], // Words to always censor
    neverCensor: [], // Words to never censor
  },
  replacements: [ // Static find/replace pairs
    { find: "Mucks", replace: "Mux" },
  ],
  uploadToMux: true, // Upload edited track to Mux (default: true)
  deleteOriginalTrack: true, // Delete original after upload (default: true)
});
```

## Audio Dubbing

Create AI-dubbed audio tracks using ElevenLabs voice cloning (video or audio-only assets).

```typescript
import { translateAudio } from "@mux/ai/workflows";

// Create dubbed audio and upload to Mux
// Uses default audio track; source language auto-detected unless provided
const result = await translateAudio(
  "your-mux-asset-id",
  "es", // target language
  {
    provider: "elevenlabs",
    fromLanguageCode: "en", // optional source language
    numSpeakers: 0 // Auto-detect speakers
  }
);

console.log(result.dubbingId); // ElevenLabs dubbing job ID
console.log(result.uploadedTrackId); // New Mux audio track ID
console.log(result.presignedUrl); // S3 audio file URL
```

### Requirements

- Asset must have an `audio.m4a` static rendition
- ElevenLabs API key with Creator plan or higher
- S3-compatible storage (same as caption translation)

### Supported Languages

ElevenLabs supports 32+ languages with automatic language name detection via `Intl.DisplayNames`. Supported languages include English, Spanish, French, German, Italian, Portuguese, Polish, Japanese, Korean, Chinese, Russian, Arabic, Hindi, Thai, and many more. Track names are automatically generated (e.g., "Polish (auto-dubbed)").

### Audio Dubbing Workflow

1. Checks asset has audio.m4a static rendition
2. Downloads default audio track from Mux
3. Creates ElevenLabs dubbing job (source language auto-detected unless `fromLanguageCode` is set)
4. Polls for completion (up to 30 minutes)
5. Downloads dubbed audio file
6. Uploads to S3-compatible storage
7. Generates presigned URL (default 24-hour expiry, configurable via `s3SignedUrlExpirySeconds`)
8. Adds new audio track to Mux asset
9. Track name: "{Language} (auto-dubbed)"

## Multi-Provider Support

All workflows support multiple AI providers with consistent interfaces.

### Comparing Providers

Run the same workflow across different providers to compare results:

```typescript
import { getSummaryAndTags } from "@mux/ai/workflows";

const assetId = "your-mux-asset-id";

// OpenAI analysis (default: gpt-5.1)
const openaiResult = await getSummaryAndTags(assetId, {
  provider: "openai",
  tone: "professional"
});

// Anthropic analysis (default: claude-sonnet-4-5)
const anthropicResult = await getSummaryAndTags(assetId, {
  provider: "anthropic",
  tone: "professional"
});

// Google Gemini analysis (default: gemini-3-flash-preview)
const googleResult = await getSummaryAndTags(assetId, {
  provider: "google",
  tone: "professional"
});

// Compare results
console.log("OpenAI:", openaiResult.title);
console.log("Anthropic:", anthropicResult.title);
console.log("Google:", googleResult.title);
```

Works with any workflow:

```typescript
import { generateChapters } from "@mux/ai/workflows";

// OpenAI (default: gpt-5.1)
const openaiChapters = await generateChapters(assetId, {
  provider: "openai"
});

// Anthropic (default: claude-sonnet-4-5)
const anthropicChapters = await generateChapters(assetId, {
  provider: "anthropic"
});

// Google (default: gemini-3-flash-preview)
const googleChapters = await generateChapters(assetId, {
  provider: "google"
});
```

### Overriding Default Models

Override default models when you need different cost or capability trade-offs:

```typescript
import { getSummaryAndTags } from "@mux/ai/workflows";

// Use a more powerful model
const result = await getSummaryAndTags(assetId, {
  provider: "openai",
  model: "gpt-5.4" // Instead of default gpt-5.1
});

// Use a faster/cheaper model
const fastResult = await getSummaryAndTags(assetId, {
  provider: "google",
  model: "gemini-3.1-flash-lite" // Smallest/fastest Gemini
});
```

**Cost Optimization Tip:** The defaults (`gpt-5.1`, `claude-sonnet-4-5`, `gemini-3-flash-preview`) are optimized for cost/quality balance. Only upgrade to more powerful models when quality needs justify the higher cost.