diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
index c93f7aed7d..f1eb8b6250 100644
--- a/.github/copilot-instructions.md
+++ b/.github/copilot-instructions.md
@@ -361,8 +361,6 @@ class Resources:
     cpus: float = 1.0 # Number of CPU cores
     gpu_memory_gb: float = 0.0 # Number of GPU memory in GB (Only for single GPU)
     gpus: float = 0.0 # Number of GPUs (Only for multi-GPU)
-    nvdecs: int = 0 # Number of NVDEC decoders
-    nvencs: int = 0 # Number of NVENC encoders
     entire_gpu: bool = False # Whether to use the entire GPU
 ```
 
diff --git a/api-design.md b/api-design.md
index 03491ee846..1a0d0c7a11 100644
--- a/api-design.md
+++ b/api-design.md
@@ -132,8 +132,6 @@ class Resources:
     cpus: float = 1.0 # Number of CPU cores
     gpu_memory_gb: float = 0.0 # Number of GPU memory in GB (Only for single GPU)
     gpus: float = 0.0 # Number of GPUs (Only for multi-GPU)
-    nvdecs: int = 0 # Number of NVDEC decoders
-    nvencs: int = 0 # Number of NVENC encoders
     entire_gpu: bool = False # Whether to use the entire GPU
 ```
 
diff --git a/docs/about/concepts/video/abstractions.md b/docs/about/concepts/video/abstractions.md
index af08e00206..1f1d7923c0 100644
--- a/docs/about/concepts/video/abstractions.md
+++ b/docs/about/concepts/video/abstractions.md
@@ -48,7 +48,7 @@ A stage represents a single step in your data curation workflow. Video stages ar
 Each processing stage:
 
 1. Inherits from `ProcessingStage`
-2. Declares a stable `name` and `resources: Resources` (CPU cores, GPU memory, optional NVDEC/NVENC, or more than one GPU)
+2. Declares a stable `name` and `resources: Resources` (CPU cores, GPU memory, entire GPU flag, or multiple GPUs)
 3. Defines `inputs()`/`outputs()` to document required attributes and produced attributes on tasks
 4. Implements `setup(worker_metadata)` for model initialization and `process(task)` to transform tasks
 
@@ -75,9 +75,8 @@ Refer to the stage base and resources definitions in Curator for full details.
 `Resources` support both fractional and whole‑GPU semantics:
 
 - `gpu_memory_gb`: Request a fraction of a single GPU by memory; Curator rounds to a fractional GPU share and enforces that `gpu_memory_gb` stays within one device.
-- `entire_gpu`: Request an entire GPU regardless of memory (also implies access to NVDEC/NVENC on that device).
+- `entire_gpu`: Request an entire GPU regardless of memory (also implies access to hardware decoders and encoders on that device).
 - `gpus`: Request more than one GPU for a stage that is multi‑GPU aware.
-- `nvdecs` / `nvencs`: Request hardware decode/encode units when needed.
 
 Choose one of `gpu_memory_gb` (single‑GPU fractional) or `gpus` (multi‑GPU). Combining both is not allowed.
 
diff --git a/docs/curate-audio/tutorials/beginner.md b/docs/curate-audio/tutorials/beginner.md
index d41b3c0839..9691df8651 100644
--- a/docs/curate-audio/tutorials/beginner.md
+++ b/docs/curate-audio/tutorials/beginner.md
@@ -55,7 +55,7 @@ cd NeMo-Curator/tutorials/audio/fleurs/
 
 ## Prerequisites
 
-* NeMo Curator installed (see [Installation Guide](docs/admin/installation.md))
+* NeMo Curator installed (see [Installation Guide](admin-installation))
 * NVIDIA GPU (required for ASR inference, minimum 16GB VRAM recommended)
 * Internet connection for dataset download
 * Basic Python knowledge
@@ -373,7 +373,7 @@ After completing this tutorial, explore:
 
 ## Related Topics
 
-- **[Audio Curation Quickstart](docs/get-started/audio.md)**: Quick introduction to audio curation
+- **[Audio Curation Quickstart](gs-audio)**: Quick introduction to audio curation
 - **[FLEURS Dataset](../load-data/fleurs-dataset.md)**: Detailed FLEURS dataset documentation
 - **[Quality Assessment](../process-data/quality-assessment/index.md)**: Comprehensive quality metrics guide
 - **[Save & Export](../save-export.md)**: Advanced export options and formats
diff --git a/docs/curate-text/process-data/deduplication/index.md b/docs/curate-text/process-data/deduplication/index.md
index 042f3f0679..a6cfb8dc6e 100644
--- a/docs/curate-text/process-data/deduplication/index.md
+++ b/docs/curate-text/process-data/deduplication/index.md
@@ -126,7 +126,7 @@ text_workflow.run()
 - `TextSemanticDeduplicationWorkflow`: For raw text with automatic embedding generation
 - `SemanticDeduplicationWorkflow`: For pre-computed embeddings
 
-See {ref}`Semantic Deduplication <text-process-data-dedup-semdedup>` for details.
+See {ref}`Semantic Deduplication <text-process-data-format-sem-dedup>` for details.
 :::
 
 :::{dropdown} Advanced: Step-by-Step Semantic Deduplication
@@ -378,7 +378,7 @@ For detailed implementation guides, see:
 
 - {ref}`Exact Duplicate Removal <text-process-data-dedup-exact>`
 - {ref}`Fuzzy Duplicate Removal <text-process-data-dedup-fuzzy>`
-- {ref}`Semantic Deduplication <text-process-data-dedup-semdedup>`
+- {ref}`Semantic Deduplication <text-process-data-format-sem-dedup>`
 
 :::{dropdown} Performance Considerations
 :icon: zap
@@ -455,7 +455,7 @@ The ID Generator ensures consistent IDs across workflow stages.
 
 - **New to deduplication**: Start with {ref}`Exact Duplicate Removal <text-process-data-dedup-exact>` for the fastest approach
 - **Need near-duplicate detection**: See {ref}`Fuzzy Duplicate Removal <text-process-data-dedup-fuzzy>` for MinHash-based matching
-- **Require semantic matching**: Explore {ref}`Semantic Deduplication <text-process-data-dedup-semdedup>` for meaning-based deduplication
+- **Require semantic matching**: Explore {ref}`Semantic Deduplication <text-process-data-format-sem-dedup>` for meaning-based deduplication
 
 **For hands-on guidance**: See {ref}`Text Curation Tutorials <text-tutorials>` for step-by-step examples.
 
diff --git a/docs/curate-video/index.md b/docs/curate-video/index.md
index 7a5fcf6179..82d873bfab 100644
--- a/docs/curate-video/index.md
+++ b/docs/curate-video/index.md
@@ -33,7 +33,7 @@ Understand how components work together so you can plan, scale, and troubleshoot
 ```
 
 ```{note}
-Video pipelines use the `XennaExecutor` backend by default, which provides optimized support for GPU-accelerated video processing including hardware decoders (`nvdecs`) and encoders (`nvencs`). You do not need to import or configure the executor unless you want to use an alternative backend. For more information about customizing backends, refer to [Add a Custom Stage](video-tutorials-pipeline-cust-add-stage).
+Video pipelines use the `XennaExecutor` backend by default, which provides optimized support for GPU-accelerated video processing including hardware decoders and encoders. You do not need to import or configure the executor unless you want to use an alternative backend. For more information about customizing backends, refer to [Pipeline Execution Backends](reference-execution-backends).
 ```
 
 ---
diff --git a/docs/curate-video/load-data/index.md b/docs/curate-video/load-data/index.md
index 3adccc3548..c982deb594 100644
--- a/docs/curate-video/load-data/index.md
+++ b/docs/curate-video/load-data/index.md
@@ -18,11 +18,20 @@ Load video data for curation using NeMo Curator.
 
 NeMo Curator loads videos with a composite stage that discovers files and extracts metadata:
 
-1. `VideoReader` decomposes into a partitioning stage plus a reader stage.
-2. Local paths use `FilePartitioningStage` to list files; remote URLs (for example, `s3://`, `gcs://`, `http(s)://`) use `ClientPartitioningStage` backed by `fsspec`.
-3. For remote datasets, you can optionally supply an explicit file list using `ClientPartitioningStage.input_list_json_path`.
-4. `VideoReaderStage` downloads bytes (local or via `FSPath`) and calls `video.populate_metadata()` to extract resolution, fps, duration, encoding format, and other fields.
-5. Set `video_limit` to cap discovery; use `None` for unlimited. Set `verbose=True` to log detailed per-video information.
+`VideoReader` is a composite stage that is broken down into a
+1. Partitioning (list files) stage
+  - Local paths use `FilePartitioningStage` to list files
+  - Remote URLs (for example, `s3://`, `gcs://`)
+    - use `ClientPartitioningStage` backed by `fsspec`.
+    - Optional `input_list_json_path` allows explicit file lists under a root prefix.
+
+2. Reader stage (`VideoReaderStage`)
+  - This stage downloads the bytes (local or via `FSPath`) for each listed file
+  - Calls `video.populate_metadata()` to extract resolution, fps, duration, encoding format, and other fields.
+
+You can set
+  - `video_limit` to limit the number of files to be processed; use `None` for unlimited.
+  - `verbose=True` to log detailed per-video information.
 
 ---
 
@@ -32,24 +41,6 @@ NeMo Curator loads videos with a composite stage that discovers files and extrac
 
 Use `VideoReader` to load videos from local paths or remote URLs.
 
-### Local Paths
-
-- Examples: `/data/videos/`, `/mnt/datasets/av/`
-- Uses `FilePartitioningStage` to recursively discover files.
-- Filters by extensions: `.mp4`, `.mov`, `.avi`, `.mkv`, `.webm`.
-- Set `video_limit` to cap discovery during testing (`None` means unlimited).
-
-### Remote Paths
-
-- Examples: `s3://bucket/path/`, `gcs://bucket/path/`, `https://host/path/`, and other fsspec-supported protocols such as `s3a://` and `abfs://`.
-- Uses `ClientPartitioningStage` backed by `fsspec` to list files.
-- Optional `input_list_json_path` allows explicit file lists under a root prefix.
-- Wraps entries as `FSPath` for efficient byte access during reading.
-
-```{tip}
-Use an object storage prefix (for example, `s3://my-bucket/videos/`) to stream from cloud storage. Configure credentials in your environment or client configuration.
-```
-
 ### Example
 
 ```python
diff --git a/docs/curate-video/process-data/dedup.md b/docs/curate-video/process-data/dedup.md
index 111e9f107b..6cba46e520 100644
--- a/docs/curate-video/process-data/dedup.md
+++ b/docs/curate-video/process-data/dedup.md
@@ -10,13 +10,18 @@ modality: "video-only"
 
 (video-process-dedup)=
 
-# Duplicate Removal
+# Duplicate Identification
+
+Use clip-level embeddings to identify near-duplicate video clips so your dataset remains compact, diverse, and efficient to train on.
+
+## Before You Start
+- Make sure you have embeddings which are written by the [`ClipWriterStage`](video-save-export) under `iv2_embd_parquet/` or `ce1_embd_parquet/`. For a runnable workflow, refer to the [Split and Remove Duplicates Workflow](video-tutorials-split-dedup). The embeddings must be in parquet files containing the columns `id` and `embedding`.
+- Verify local paths or configure S3-compatible credentials. Provide `storage_options` in read/write keyword arguments when reading or writing cloud paths.
 
-Use clip-level embeddings to identify and remove near-duplicate video clips so your dataset remains compact, diverse, and efficient to train on.
 
 ## How it Works
 
-Duplicate removal operates on clip-level embeddings produced during processing:
+Duplicate identification operates on clip-level embeddings produced during processing:
 
 1. **Inputs**
    - Parquet batches from `ClipWriterStage` under `iv2_embd_parquet/` or `ce1_embd_parquet/`
@@ -27,73 +32,173 @@ Duplicate removal operates on clip-level embeddings produced during processing:
    - Pairwise: `PairwiseStage` computes within-cluster similarity on GPU and, for each clip, emits `max_id` and `cosine_sim_score`. Ranking controls whether to prefer outliers ("hard") or representatives ("easy").
    - Identify: `IdentifyDuplicatesStage` filters pairs with `cosine_sim_score >= 1.0 - eps` and writes Parquet files of duplicate `id`s for removal during export.
 
-## Before You Start
-
-- Verify local paths or configure S3-compatible credentials. Provide `storage_options` in read/write keyword arguments when reading or writing cloud paths.
-- Create output directories for `KMeansStage`, `PairwiseStage`, and `IdentifyDuplicatesStage`.
-
 ---
 
 ## Quickstart
 
-Use the generic semantic duplicate-removal stages with clip embeddings written to Parquet.
+Use the semantic duplicate workflow with clip embeddings written to Parquet.
+
+:::::{tab-set}
 
-::::{tab-set}
+::::{tab-item} Single Step Workflow
 
-:::{tab-item} Pipeline Stage
+The `SemanticDeduplicationWorkflow` provides an end-to-end interface that orchestrates K-means clustering, pairwise similarity computation, and duplicate identification:
 
 ```python
-from nemo_curator.stages.deduplication.semantic.kmeans import KMeansStage
-from nemo_curator.stages.deduplication.semantic.pairwise import PairwiseStage
+from nemo_curator.stages.deduplication.semantic.workflow import SemanticDeduplicationWorkflow
 from nemo_curator.stages.deduplication.semantic.ranking import RankingStrategy
-from nemo_curator.stages.deduplication.semantic.identify_duplicates import IdentifyDuplicatesStage
+from nemo_curator.backends.xenna import XennaExecutor
 
-kmeans = KMeansStage(
+workflow = SemanticDeduplicationWorkflow(
+    input_path="/path/to/embeddings/",  # e.g., iv2_embd_parquet/ or ce1_embd_parquet/
+    output_path="/path/to/duplicates/",
+    cache_path="/path/to/cache/",  # Optional: defaults to output_path
     n_clusters=1000,
     id_field="id",
     embedding_field="embedding",
-    input_path="/path/to/embeddings/",
-    output_path="/path/to/kmeans_out/",
+    embedding_dim=512,  # 512 for InternVideo2, varies for Cosmos-Embed1
     input_filetype="parquet",
-)
-
-pairwise = PairwiseStage(
-    id_field="id",
-    embedding_field="embedding",
-    input_path="/path/to/kmeans_out/",
-    output_path="/path/to/pairwise_out/",
+    eps=0.1,  # Similarity threshold: cosine_sim >= 1.0 - eps identifies duplicates
     ranking_strategy=RankingStrategy.metadata_based(
         metadata_cols=["cosine_dist_to_cent", "id"],
         ascending=[True, True],
     ),
+    pairwise_batch_size=1024,
+    read_kwargs={"storage_options": None},  # Add S3 credentials here if needed
+    write_kwargs={"storage_options": None},
+    verbose=True,
 )
 
-identify = IdentifyDuplicatesStage(
-    output_path="/path/to/duplicates/",
-    eps=0.1,
-)
+# Run with XennaExecutor (GPU-accelerated)
+executor = XennaExecutor()
+results = workflow.run(executor)
 ```
 
+:::{note}
+**Determine `eps` first**: Before running the full workflow, we recommend first running K-means and pairwise steps (set `eps=None`) to inspect similarity distributions and determine an appropriate `eps` threshold. See the tip below for details.
 :::
 
-:::{tab-item} Script Flags
+The workflow automatically:
+1. Runs K-means clustering to partition embeddings into clusters
+2. Computes pairwise similarity within each cluster
+3. Identifies duplicates based on the `eps` threshold
+4. Writes duplicate IDs to `output_path/duplicates/`
 
-No example script flags are available for duplicate removal in the split pipeline. Run these stages as a separate job against Parquet embeddings written by the example pipeline's writer.
+```{seealso}
+For detailed information about how semantic deduplication works, see [Semantic Deduplication](text-process-data-format-sem-dedup). The algorithm and concepts are the same for video clips as for text documents.
+```
 
-:::
 ::::
 
-Input format: Parquet with columns `id` and `embedding` (produced by the video pipeline’s embedding stages and writer). Duplicate removal operates at the clip level using these embeddings. The `IdentifyDuplicatesStage` writes Parquet files containing duplicate `id`s; perform removal by filtering out rows whose `id` appears in those files during export.
+::::{tab-item} Individual Stages
 
-```{seealso}
-Embeddings are written by the [`ClipWriterStage`](video-save-export) under `iv2_embd_parquet/` or `ce1_embd_parquet/`. For a runnable workflow, refer to the [Split and Remove Duplicates Workflow](video-tutorials-split-dedup).
+For advanced users who need fine-grained control, you can run the stages individually:
+
+```python
+from nemo_curator.pipeline import Pipeline
+from nemo_curator.stages.deduplication.semantic.kmeans import KMeansStage
+from nemo_curator.stages.deduplication.semantic.pairwise import PairwiseStage
+from nemo_curator.stages.deduplication.semantic.ranking import RankingStrategy
+from nemo_curator.stages.deduplication.semantic.identify_duplicates import IdentifyDuplicatesStage
+
+pipe = Pipeline(name="semantic_dedup")
+
+pipe.add_stage(
+    KMeansStage(
+        n_clusters=1000,
+        id_field="id",
+        embedding_field="embedding",
+        input_path="/path/to/embeddings/",
+        output_path="/path/to/kmeans_out/",
+        input_filetype="parquet",
+        embedding_dim=512,
+    )
+)
+
+pipe.add_stage(
+    PairwiseStage(
+        id_field="id",
+        embedding_field="embedding",
+        input_path="/path/to/kmeans_out/",
+        output_path="/path/to/pairwise_out/",
+        ranking_strategy=RankingStrategy.metadata_based(
+            metadata_cols=["cosine_dist_to_cent", "id"],
+            ascending=[True, True],
+        ),
+    )
+)
+
+pipe.add_stage(
+    IdentifyDuplicatesStage(
+        output_path="/path/to/duplicates/",
+        eps=0.1,
+    )
+)
+
+pipe.run()
 ```
 
+::::
+
+::::{tab-item} Script Flags
+
+No example script flags are available for duplicate identification in the split pipeline. Run these stages as a separate job against Parquet embeddings written by the example pipeline's writer.
+
+::::
+:::::
+
+:::{tip}
+**Recommended Workflow: Determine `eps` First**
+
+The `eps` parameter is highly data-dependent and affects how many duplicates are identified. We recommend a two-step approach:
+
+1. **Step 1: Run K-means and pairwise without duplicate identification**
+   - Use `SemanticDeduplicationWorkflow` with `eps=None` (or run K-means and pairwise stages individually)
+   - This generates pairwise similarity scores without identifying duplicates
+
+2. **Step 2: Inspect the similarity distribution**
+   - Analyze the `cosine_sim_score` values in the pairwise results
+   - Determine an appropriate `eps` threshold based on your data characteristics
+   - For example, if 20% of pairs have similarity ≥ 0.9, you might use `eps=0.1` (since `cosine_sim >= 1.0 - eps`)
+
+3. **Step 3: Run the full workflow with your chosen `eps`**
+   - Use `SemanticDeduplicationWorkflow` with the determined `eps` value
+   - Or run `IdentifyDuplicatesStage` separately on the pairwise results
+
+For a detailed example of this workflow with similarity analysis, see the [Step-by-Step Semantic Deduplication tutorial](https://github.com/NVIDIA-NeMo/Curator/blob/main/tutorials/text/deduplication/semantic/semantic_step_by_step.ipynb) (demonstrated on text data, but the approach applies to video clips as well).
+:::
+
+:::{tip}
+**Custom Ranking with Metadata Columns**
+
+If your embedding Parquet files contain additional metadata columns (such as video quality scores, duration, resolution, or other clip attributes), you can use `RankingStrategy.metadata_based()` to create custom ranking methods. This allows you to prioritize which clips to keep within duplicate groups based on your specific criteria.
+
+For example, to prefer higher quality or longer duration clips:
+
+```python
+from nemo_curator.stages.deduplication.semantic.ranking import RankingStrategy
+
+# Prefer clips with higher quality scores, then longer duration
+ranking_strategy = RankingStrategy.metadata_based(
+    metadata_cols=["quality_score", "duration"],
+    ascending=[False, False],  # False = descending (higher is better)
+)
+
+# Or prefer clips closer to cluster centroid, then by quality
+ranking_strategy = RankingStrategy.metadata_based(
+    metadata_cols=["cosine_dist_to_cent", "quality_score"],
+    ascending=[True, False],  # Closer to centroid first, then higher quality
+)
+```
+
+The metadata columns must be present in your embedding Parquet files and will be preserved through the K-means stage. Specify these columns using the `metadata_fields` parameter in `KMeansStage` or `SemanticDeduplicationWorkflow`.
+:::
+
 ## Parameters
 
-::::{tab-set}
+:::::{tab-set}
 
-:::{tab-item} KMeansStage
+::::{tab-item} KMeansStage
 
 ```{list-table} KMeansStage (semantic clustering)
 :header-rows: 1
@@ -116,23 +221,86 @@ Embeddings are written by the [`ClipWriterStage`](video-save-export) under `iv2_
   - Embedding dimension (Cosmos‑Embed1 varies by variant: 768 for most).
 ```
 
-:::
+::::
 
-:::{tab-item} PairwiseStage
+::::{tab-item} PairwiseStage
 
 ```{list-table} PairwiseStage (within‑cluster similarity)
 :header-rows: 1
 
 * - Parameter
   - Description
-* - `which_to_keep`
-  - `"hard"` keeps outliers far from centroid; `"easy"` keeps nearest to centroid; `"random"` ignores distance.
-* - `sim_metric`
-  - `"cosine"` (default) or `"l2"` affects centroid distances and ranking.
 * - `ranking_strategy`
-  - Optional explicit ranking (overrides switches). Use `RankingStrategy.metadata_based([...])`.
+  - Ranking strategy for selecting which clips to keep within clusters. Use `RankingStrategy.metadata_based(metadata_cols=[...], ascending=[...])` to sort by metadata columns (for example, `metadata_cols=["cosine_dist_to_cent", "id"]`). Use `RankingStrategy.random()` for random selection.
 * - `pairwise_batch_size`
   - Batch size for GPU pairwise computation (default `1024`). Increase with available memory.
 * - `embedding_dim`
   - Embedding dimension for memory estimates and batching.
-* - `
\ No newline at end of file
+* - `id_field`
+  - Column name containing clip IDs (for example, `"id"`).
+* - `embedding_field`
+  - Column with vector data (for example, `"embedding"`).
+* - `input_path`
+  - Path to K-means output directory (sharded by cluster).
+* - `output_path`
+  - Directory for pairwise similarity outputs.
+```
+
+::::
+
+::::{tab-item} IdentifyDuplicatesStage
+
+```{list-table} IdentifyDuplicatesStage (duplicate identification)
+:header-rows: 1
+
+* - Parameter
+  - Description
+* - `output_path`
+  - Directory to write Parquet files containing duplicate `id`s.
+* - `eps`
+  - Similarity threshold: pairs with `cosine_sim_score >= 1.0 - eps` are identified as duplicates (for example, `0.1` means similarity >= `0.9`).
+* - `read_kwargs`
+  - Optional keyword arguments for reading files (including `storage_options` for cloud storage).
+* - `write_kwargs`
+  - Optional keyword arguments for writing files (including `storage_options` for cloud storage).
+* - `verbose`
+  - Enable verbose logging (default `False`).
+```
+
+::::
+
+::::{tab-item} SemanticDeduplicationWorkflow
+
+The `SemanticDeduplicationWorkflow` accepts parameters from all three stages (KMeansStage, PairwiseStage, and IdentifyDuplicatesStage). See the tabs above for parameter descriptions.
+
+```{list-table} SemanticDeduplicationWorkflow (workflow-specific parameters)
+:header-rows: 1
+
+* - Parameter
+  - Description
+* - `cache_path`
+  - Directory for intermediate results (K-means and pairwise outputs). Defaults to `output_path` if not specified.
+* - `cache_kwargs`
+  - Optional keyword arguments for writing cache files (including `storage_options` for cloud storage). Defaults to `write_kwargs` if not specified.
+* - `clear_output`
+  - Clear output directory before running (default `True`).
+* - `metadata_fields`
+  - List of metadata field names to preserve in output (optional).
+```
+
+For parameters shared with individual stages, refer to:
+- **KMeansStage** tab: `input_path`, `output_path`, `n_clusters`, `id_field`, `embedding_field`, `embedding_dim`
+- **PairwiseStage** tab: `ranking_strategy`, `pairwise_batch_size`
+- **IdentifyDuplicatesStage** tab: `eps`
+- Common parameters: `read_kwargs`, `write_kwargs`, `verbose`
+
+::::
+:::::
+
+---
+
+## Removing Duplicates
+
+The duplicate identification stages (`IdentifyDuplicatesStage` or `SemanticDeduplicationWorkflow` with `eps` specified) write Parquet files containing duplicate clip IDs to the output directory (typically `output_path/duplicates/`). These files contain a single column `id` with the IDs of clips that should be removed.
+
+**It is your responsibility to exclude these duplicate IDs when exporting or persisting your final dataset.** The removal process depends on how you want to persist and shard your data:
diff --git a/docs/curate-video/process-data/frame-extraction.md b/docs/curate-video/process-data/frame-extraction.md
index 17f7c2df70..30d9c3bc5f 100644
--- a/docs/curate-video/process-data/frame-extraction.md
+++ b/docs/curate-video/process-data/frame-extraction.md
@@ -23,7 +23,7 @@ Extract frames from clips or full videos at target rates and resolutions. Use fr
 
 ## Before You Start
 
-[Embeddings](video-process-embeddings) and [aesthetic filtering](video-process-filtering-aesthetic) require frames. If you need saved media files, frame extraction is optional.
+If you need saved media files, frame extraction is optional. [Embeddings](video-process-embeddings) and [aesthetic filtering](video-process-filtering-aesthetic) require frames.
 
 ---
 
diff --git a/docs/curate-video/tutorials/pipeline-customization/add-cust-env.md b/docs/curate-video/tutorials/pipeline-customization/add-cust-env.md
index da9da2283e..18fc84105a 100644
--- a/docs/curate-video/tutorials/pipeline-customization/add-cust-env.md
+++ b/docs/curate-video/tutorials/pipeline-customization/add-cust-env.md
@@ -70,7 +70,3 @@ docker build -t my-ray-curator:latest .
 ## Next Steps
 
 Now that you have created a custom environment, you can [create custom code](video-tutorials-pipeline-cust-add-code) for that environment.
-
-```{note}
-Ray Data backends do not support `nvdecs`/`nvencs` resource keys. Xenna does. If you plan to use `nvdecs`/`nvencs`, prefer the default Xenna executor.
-```
diff --git a/docs/curate-video/tutorials/pipeline-customization/add-cust-model.md b/docs/curate-video/tutorials/pipeline-customization/add-cust-model.md
index e742dc7920..52ffe9f821 100644
--- a/docs/curate-video/tutorials/pipeline-customization/add-cust-model.md
+++ b/docs/curate-video/tutorials/pipeline-customization/add-cust-model.md
@@ -131,7 +131,7 @@ The setup method initializes the underlying `MyCore` class that performs the mod
 
 The `model_id_names` property returns a list of weight IDs. These typically correspond to model repository names but do not have to.
 
-If your stage requires a specific environment, manage that in the stage’s `resources` (for example, `gpu_memory_gb`, `nvdecs`, `nvencs`) and container image, rather than on the model. GPU allocation is managed at the stage level using `Resources`, not on the model.
+If your stage requires a specific environment, manage that in the stage's `resources` (for example, `gpu_memory_gb`, `entire_gpu`, or `gpus`) and container image, rather than on the model. GPU allocation is managed at the stage level using `Resources`, not on the model.
 
 ### Manage model weights
 
diff --git a/docs/curate-video/tutorials/pipeline-customization/add-cust-stage.md b/docs/curate-video/tutorials/pipeline-customization/add-cust-stage.md
index 3520b7ea1d..2914b8434f 100644
--- a/docs/curate-video/tutorials/pipeline-customization/add-cust-stage.md
+++ b/docs/curate-video/tutorials/pipeline-customization/add-cust-stage.md
@@ -61,7 +61,7 @@ class MyCustomStage(ProcessingStage[VideoTask, VideoTask]):
 from nemo_curator.stages.resources import Resources
 
 stage = MyCustomStage().with_(
-    resources=Resources(cpus=4.0, gpu_memory_gb=16.0, nvdecs=1, nvencs=1)
+    resources=Resources(cpus=4.0, gpu_memory_gb=16.0)
 )
 ```
 
@@ -160,6 +160,3 @@ For end-to-end usage, review and adapt the example:
 
 If you need a container image, extend your base image using a Dockerfile and include your code and dependencies. Then build and run with your preferred container tooling.
 
-```{note}
-Ray Data backends do not support `nvdecs`/`nvencs` resource keys. Xenna does. If you plan to use `nvdecs`/`nvencs`, prefer the default Xenna executor.
-```
diff --git a/docs/get-started/audio.md b/docs/get-started/audio.md
index c90a32e3b9..0f4bd5d057 100644
--- a/docs/get-started/audio.md
+++ b/docs/get-started/audio.md
@@ -90,7 +90,7 @@ docker run --gpus all -it --rm nvcr.io/nvidia/nemo-curator:{{ container_version
 ```
 
 ```{seealso}
-For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments-main).
+For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments).
 ```
 
 :::
diff --git a/docs/get-started/image.md b/docs/get-started/image.md
index 350e0712d3..588028621b 100644
--- a/docs/get-started/image.md
+++ b/docs/get-started/image.md
@@ -85,7 +85,7 @@ docker run --gpus all -it --rm nvcr.io/nvidia/nemo-curator:{{ container_version
 ```
 
 ```{seealso}
-For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments-main).
+For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments).
 ```
 
 :::
diff --git a/docs/get-started/text.md b/docs/get-started/text.md
index c168c1d9a5..9b7258f60b 100644
--- a/docs/get-started/text.md
+++ b/docs/get-started/text.md
@@ -88,7 +88,7 @@ docker run --gpus all -it --rm nvcr.io/nvidia/nemo-curator:{{ container_version
 ```
 
 ```{seealso}
-For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments-main).
+For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments).
 ```
 
 :::
diff --git a/docs/get-started/video.md b/docs/get-started/video.md
index 0173f64733..6354c1551d 100644
--- a/docs/get-started/video.md
+++ b/docs/get-started/video.md
@@ -113,7 +113,7 @@ docker run --gpus all -it --rm nvcr.io/nvidia/nemo-curator:{{ container_version
 ```
 
 ```{seealso}
-For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments-main).
+For details on container environments and configurations, see [Container Environments](reference-infrastructure-container-environments).
 ```
 
 :::