+ );
+}
diff --git a/fern/components/containers.ts b/fern/components/containers.ts
new file mode 100644
index 0000000..6bc3da9
--- /dev/null
+++ b/fern/components/containers.ts
@@ -0,0 +1,127 @@
+/**
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Canonical NGC containers for NeMo OSS — distinct from the 22-repo library catalog.
+ * Update `latestTag` and `FRAMEWORK_RECENT_RELEASES` when a new Framework container ships.
+ */
+
+import type { RepoStage } from "./repos";
+
+export type ContainerKind = "multi-library" | "standalone";
+
+export interface NemoContainer {
+ /** Display name on NGC */
+ name: string;
+ /** Full image without tag, e.g. nvcr.io/nvidia/nemo */
+ image: string;
+ ngcUrl: string;
+ description: string;
+ kind: ContainerKind;
+ /** Primary lifecycle stages this container supports */
+ stages: RepoStage[];
+ latestTag?: string;
+ docsUrl?: string;
+ /** Bundled libraries (multi-library Framework container only) */
+ bundledLibraries?: string[];
+ tags?: string[];
+}
+
+export const CONTAINER_KINDS: { id: ContainerKind | "all"; label: string }[] = [
+ { id: "all", label: "All" },
+ { id: "multi-library", label: "Multi-library" },
+ { id: "standalone", label: "Standalone" },
+];
+
+export const CONTAINER_STAGES: { id: RepoStage | "all"; label: string }[] = [
+ { id: "all", label: "All stages" },
+ { id: "data", label: "Data" },
+ { id: "pretraining", label: "Pretraining" },
+ { id: "rl", label: "RL" },
+ { id: "inference", label: "Inference" },
+ { id: "e2e", label: "E2E" },
+];
+
+/** Recent NeMo Framework container tags — keep last three. */
+export interface FrameworkRelease {
+ tag: string;
+ summary: string;
+}
+
+export const FRAMEWORK_RECENT_RELEASES: FrameworkRelease[] = [
+ {
+ tag: "26.02",
+ summary:
+ "Updated Megatron-Bridge, Evaluator, Export-Deploy, Run, and Speech. See Megatron-Bridge software component versions for pinned packages.",
+ },
+ {
+ tag: "25.11.01",
+ summary: "Patch release. See Megatron-Bridge and Export-Deploy release notes.",
+ },
+ {
+ tag: "25.11",
+ summary:
+ "Updates across Megatron-Bridge, Evaluator, Export-Deploy, Run, and Speech. Evaluator adds direct nemo-evaluator use, Logprob benchmarks, and multi-node Ray evaluations via NeMo Run.",
+ },
+];
+
+export const SOFTWARE_VERSIONS_URL =
+ "https://docs.nvidia.com/nemo/megatron-bridge/latest/releases/software-versions.html";
+
+export const NGC_NEMO_TEAM_URL =
+ "https://catalog.ngc.nvidia.com/orgs/nvidia/teams/nemo/containers";
+
+/** Published NeMo OSS containers on NGC (standalone + multi-library stack). */
+export const NEMO_CONTAINERS: NemoContainer[] = [
+ {
+ name: "NeMo Framework",
+ image: "nvcr.io/nvidia/nemo",
+ ngcUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo",
+ description:
+ "Primary multi-library training stack — Megatron-Bridge, Evaluator, Export-Deploy, Run, and Speech in one image.",
+ kind: "multi-library",
+ stages: ["pretraining", "rl", "inference", "e2e"],
+ latestTag: "26.02",
+ docsUrl: "https://docs.nvidia.com/nemo/megatron-bridge/latest/",
+ bundledLibraries: ["Megatron-Bridge", "Evaluator", "Export-Deploy", "Run", "NeMo Speech"],
+ tags: ["llm", "vlm", "speech", "megatron"],
+ },
+ {
+ name: "NeMo AutoModel",
+ image: "nvcr.io/nvidia/nemo-automodel",
+ ngcUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-automodel",
+ description: "PyTorch-native distributed training for LLMs and VLMs with Hugging Face support.",
+ kind: "standalone",
+ stages: ["pretraining"],
+ docsUrl: "https://docs.nvidia.com/nemo/automodel/latest/",
+ tags: ["llm", "vlm", "huggingface", "pytorch"],
+ },
+ {
+ name: "NeMo RL",
+ image: "nvcr.io/nvidia/nemo-rl",
+ ngcUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-rl",
+ description: "Alignment and reinforcement learning — SFT, DPO, GRPO, and distillation.",
+ kind: "standalone",
+ stages: ["rl"],
+ docsUrl: "https://docs.nvidia.com/nemo/rl/latest/",
+ tags: ["dpo", "grpo", "alignment"],
+ },
+ {
+ name: "NeMo Curator",
+ image: "nvcr.io/nvidia/nemo-curator",
+ ngcUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-curator",
+ description: "Data preprocessing and curation for text, image, video, and audio at scale.",
+ kind: "standalone",
+ stages: ["data"],
+ docsUrl: "https://docs.nvidia.com/nemo/curator/latest/",
+ tags: ["curation", "multimodal"],
+ },
+];
+
+export function containerKindLabel(kind: ContainerKind): string {
+ return kind === "multi-library" ? "Multi-library" : "Standalone";
+}
+
+export function containerStageLabels(stages: RepoStage[]): string {
+ return stages.map((s) => CONTAINER_STAGES.find((x) => x.id === s)?.label ?? s).join(" · ");
+}
diff --git a/fern/components/repos.ts b/fern/components/repos.ts
new file mode 100644
index 0000000..455b9ff
--- /dev/null
+++ b/fern/components/repos.ts
@@ -0,0 +1,277 @@
+/**
+ * SPDX-FileCopyrightText: Copyright (c) 2026 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Canonical list of NVIDIA-NeMo GitHub organization repositories.
+ * https://github.com/orgs/NVIDIA-NeMo/repositories
+ *
+ * Taxonomy (three layers):
+ * - `stage` — README lifecycle column (Data · Pretraining · RL · Inference · E2E). Drives catalog filters.
+ * - `kind` — repo role (library · integration · reference · infrastructure). See fern/TAXONOMY.md.
+ * - `tags` — Search facets (modality, technique, role). Use for cross-cutting discovery in the search box.
+ *
+ * GitHub topic strategy (see GH-TOPICS.MD) can map `stage-*` topics to these stages when applied on repos.
+ */
+
+/** NeMo Speech docs — use /latest/ when published; /nightly/ is current. */
+export const NEMO_SPEECH_DOCS_URL = "https://docs.nvidia.com/nemo/speech/nightly/";
+
+/** Lifecycle stage — matches profile/README.md "Libraries by stage" columns. */
+export type RepoStage = "data" | "pretraining" | "rl" | "inference" | "e2e";
+
+export type RepoStatus = "active" | "archived";
+
+/** Catalog role — see fern/TAXONOMY.md */
+export type RepoKind = "library" | "integration" | "reference" | "infrastructure";
+
+export interface NemoRepo {
+ /** GitHub repo name (e.g. Automodel) */
+ name: string;
+ description: string;
+ /** Primary lifecycle stage (README columns) */
+ stage: RepoStage;
+ /** Catalog role when stage alone is misleading */
+ kind: RepoKind;
+ githubUrl: string;
+ docsUrl?: string;
+ containerUrl?: string;
+ status?: RepoStatus;
+ /** Search facets — modality, technique, or cross-cutting role (e.g. evaluation, deployment) */
+ tags?: string[];
+}
+
+/** Filter tabs — same order and labels as the org README. */
+export const REPO_STAGES: { id: RepoStage | "all"; label: string }[] = [
+ { id: "all", label: "All" },
+ { id: "data", label: "Data" },
+ { id: "pretraining", label: "Pretraining" },
+ { id: "rl", label: "RL" },
+ { id: "inference", label: "Inference" },
+ { id: "e2e", label: "E2E" },
+];
+
+export const REPO_KINDS: { id: RepoKind; label: string }[] = [
+ { id: "library", label: "Library" },
+ { id: "integration", label: "Integration" },
+ { id: "reference", label: "Reference" },
+ { id: "infrastructure", label: "Infrastructure" },
+];
+
+/** 22 open-source libraries in the NVIDIA-NeMo org (excludes the .github meta repo). */
+export const NEMO_REPOS: NemoRepo[] = [
+ // Data
+ {
+ name: "Curator",
+ description: "Scalable data preprocessing and curation for text, image, video, and audio.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Curator",
+ docsUrl: "https://docs.nvidia.com/nemo/curator/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-curator",
+ tags: ["multimodal", "curation"],
+ },
+ {
+ name: "DataDesigner",
+ description: "Generate high-quality synthetic data from scratch or from seed data.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/DataDesigner",
+ docsUrl: "https://nvidia-nemo.github.io/DataDesigner/latest/",
+ tags: ["synthetic-data", "mcp"],
+ },
+ {
+ name: "DataDesignerPlugins",
+ description: "Plugins extending NeMo Data Designer workflows.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/DataDesignerPlugins",
+ tags: ["synthetic-data", "plugins"],
+ },
+ {
+ name: "Anonymizer",
+ description: "Detect and protect PII through context-aware replacement and rewriting.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Anonymizer",
+ tags: ["pii", "privacy"],
+ },
+ {
+ name: "Safe-Synthesizer",
+ description: "Create private, safe versions of sensitive tabular datasets.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Safe-Synthesizer",
+ tags: ["privacy", "tabular"],
+ },
+ {
+ name: "SDG-PGMs",
+ description: "Build probabilistic graphical models (PGMs) for synthetic data generation.",
+ stage: "data",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/SDG-PGMs",
+ tags: ["synthetic-data", "pgm"],
+ },
+ // Pretraining
+ {
+ name: "Automodel",
+ description: "PyTorch distributed training for LLMs/VLMs with Hugging Face support.",
+ stage: "pretraining",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Automodel",
+ docsUrl: "https://docs.nvidia.com/nemo/automodel/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-automodel",
+ tags: ["llm", "vlm", "huggingface", "pytorch"],
+ },
+ {
+ name: "Megatron-Bridge",
+ description: "Megatron-based training with bidirectional Hugging Face checkpoint conversion.",
+ stage: "pretraining",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Megatron-Bridge",
+ docsUrl: "https://docs.nvidia.com/nemo/megatron-bridge/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo",
+ tags: ["llm", "vlm", "megatron"],
+ },
+ {
+ name: "NeMo Speech",
+ description: "Speech AI (ASR, TTS) training and inference — the NeMo GitHub repo.",
+ stage: "pretraining",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/NeMo",
+ docsUrl: NEMO_SPEECH_DOCS_URL,
+ tags: ["speech", "asr", "tts"],
+ },
+ {
+ name: "Emerging-Optimizers",
+ description: "Collection of cutting-edge optimizers for large-scale training.",
+ stage: "pretraining",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Emerging-Optimizers",
+ docsUrl: "https://docs.nvidia.com/nemo/emerging-optimizers/latest/index.html",
+ tags: ["optimizers"],
+ },
+ {
+ name: "DFM",
+ description: "Large-scale diffusion model training and inference (archived).",
+ stage: "pretraining",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/DFM",
+ docsUrl: "https://github.com/NVIDIA-NeMo/DFM/tree/main/docs",
+ status: "archived",
+ tags: ["diffusion"],
+ },
+ // RL
+ {
+ name: "RL",
+ description: "Scalable post-training — SFT, DPO, GRPO, distillation, and reinforcement learning.",
+ stage: "rl",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/RL",
+ docsUrl: "https://docs.nvidia.com/nemo/rl/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-rl",
+ tags: ["dpo", "grpo", "alignment", "agents"],
+ },
+ {
+ name: "Gym",
+ description: "RL environments and benchmarks to evaluate and improve models and agents.",
+ stage: "rl",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Gym",
+ docsUrl: "https://docs.nvidia.com/nemo/gym/main/about/",
+ tags: ["environments", "agents"],
+ },
+ {
+ name: "ProRL-Agent-Server",
+ description: "Rollout-as-a-service for multi-turn agent RL (pairs with NeMo RL and Gym).",
+ stage: "rl",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/ProRL-Agent-Server",
+ docsUrl: "https://github.com/NVIDIA-NeMo/ProRL-Agent-Server#readme",
+ tags: ["agents", "rollout"],
+ },
+ // Inference
+ {
+ name: "Evaluator",
+ description: "Scalable, reproducible evaluation across benchmark suites and harnesses.",
+ stage: "inference",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Evaluator",
+ docsUrl: "https://docs.nvidia.com/nemo/evaluator/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo",
+ tags: ["evaluation", "benchmarks"],
+ },
+ {
+ name: "Export-Deploy",
+ description: "Export NeMo and Hugging Face models to TRT-LLM, vLLM, ONNX, and serving stacks.",
+ stage: "inference",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Export-Deploy",
+ docsUrl: "https://docs.nvidia.com/nemo/export-deploy/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo",
+ tags: ["deployment", "serving", "vllm"],
+ },
+ {
+ name: "Guardrails",
+ description: "Programmable guardrails for LLM-based conversational systems (Colang).",
+ stage: "inference",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Guardrails",
+ docsUrl: "https://docs.nvidia.com/nemo/guardrails/latest/",
+ tags: ["safety", "agents"],
+ },
+ {
+ name: "NeMo Platform",
+ description:
+ "CLI, SDK, and web UI to evaluate, harden, tune, and deploy production agents using NeMo libraries.",
+ stage: "inference",
+ kind: "integration",
+ githubUrl: "https://github.com/NVIDIA-NeMo/nemo-platform",
+ docsUrl: "https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/",
+ tags: ["agents", "platform", "deployment"],
+ },
+ // E2E
+ {
+ name: "Skills",
+ description: "Reference pipelines for synthetic data generation and evaluation (math, code, science).",
+ stage: "e2e",
+ kind: "reference",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Skills",
+ docsUrl: "https://nvidia-nemo.github.io/Skills/",
+ tags: ["sdg", "evaluation", "pipelines"],
+ },
+ {
+ name: "Nemotron",
+ description: "Developer asset hub — recipes, cookbooks, datasets, and Nemotron reference examples.",
+ stage: "e2e",
+ kind: "reference",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Nemotron",
+ docsUrl: "https://github.com/NVIDIA-NeMo/Nemotron#readme",
+ tags: ["nemotron", "recipes"],
+ },
+ {
+ name: "Run",
+ description: "Configure, launch, and manage ML experiments (local, SLURM, Kubernetes).",
+ stage: "e2e",
+ kind: "library",
+ githubUrl: "https://github.com/NVIDIA-NeMo/Run",
+ docsUrl: "https://docs.nvidia.com/nemo/run/latest/",
+ containerUrl: "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo",
+ tags: ["orchestration", "experiments"],
+ },
+ {
+ name: "FW-CI-templates",
+ description: "CI/CD workflow templates shared across NeMo open-source libraries.",
+ stage: "e2e",
+ kind: "infrastructure",
+ githubUrl: "https://github.com/NVIDIA-NeMo/FW-CI-templates",
+ tags: ["ci", "github-actions"],
+ },
+];
+
+export function stageLabel(stage: RepoStage): string {
+ return REPO_STAGES.find((s) => s.id === stage)?.label ?? stage;
+}
+
+export function kindLabel(kind: RepoKind): string {
+ return REPO_KINDS.find((k) => k.id === kind)?.label ?? kind;
+}
diff --git a/fern/docs.yml b/fern/docs.yml
new file mode 100644
index 0000000..5fe02a6
--- /dev/null
+++ b/fern/docs.yml
@@ -0,0 +1,124 @@
+# yaml-language-server: $schema=https://schema.buildwithfern.dev/docs-yml.json
+
+instances:
+ - url: nemo.docs.buildwithfern.com/oss
+ custom-domain: docs.nvidia.com/nemo/oss
+
+title: NeMo OSS
+
+global-theme: nvidia
+
+logo:
+ href: /oss
+ right-text: NeMo OSS
+
+# GitHub org link in the top-right header (Fern `github` navbar button).
+# If the link does not appear after publish, the `nvidia` global theme may override
+# navbar-links — request an override in fern-components or add site-specific links there.
+navbar-links:
+ - type: github
+ value: https://github.com/NVIDIA-NeMo
+
+footer-links:
+ github: https://github.com/NVIDIA-NeMo
+
+experimental:
+ mdx-components:
+ - ./components
+
+redirects:
+ - source: "/oss/repositories"
+ destination: "/oss/libraries"
+ - source: "/oss/libraries"
+ destination: "/oss/about/libraries"
+ - source: "/oss/containers"
+ destination: "/oss/about/release-notes/containers"
+ - source: "/oss/about/containers"
+ destination: "/oss/about/release-notes/containers"
+ - source: "/oss/release-notes"
+ destination: "/oss/about/release-notes"
+ - source: "/oss/releases"
+ destination: "/oss/about/release-notes"
+ - source: "/oss/getting-started"
+ destination: "/oss/get-started"
+ - source: "/oss/community"
+ destination: "/oss/resources/community"
+ - source: "/oss/index.html"
+ destination: "/oss"
+ - source: "/oss/index"
+ destination: "/oss"
+ - source: "/oss/:path*/index.html"
+ destination: "/oss/:path*"
+ - source: "/oss/:path*.html"
+ destination: "/oss/:path*"
+
+navigation:
+ - section: About
+ path: docs/pages/index.mdx
+ icon: fa-duotone fa-house
+ contents:
+ - page: Ecosystem
+ path: docs/pages/about/ecosystem.mdx
+ icon: fa-duotone fa-sitemap
+ - page: Architecture
+ path: docs/pages/about/architecture.mdx
+ icon: fa-duotone fa-diagram-project
+ - folder: ./docs/pages/about/concepts
+ title: Concepts
+ slug: about/concepts
+ icon: fa-duotone fa-lightbulb
+ title-source: frontmatter
+ - page: Libraries
+ path: docs/pages/about/libraries.mdx
+ icon: fa-duotone fa-grid-2
+ - folder: ./docs/pages/about/release-notes
+ title: Release Notes
+ slug: about/release-notes
+ icon: fa-duotone fa-tag
+ title-source: frontmatter
+ - section: Get Started
+ path: docs/pages/get-started/index.mdx
+ icon: fa-duotone fa-rocket
+ contents:
+ - page: Task Map
+ path: docs/pages/get-started/task-map.mdx
+ icon: fa-duotone fa-map
+ - page: Quickstart
+ path: docs/pages/get-started/quickstart.mdx
+ icon: fa-duotone fa-bolt
+ - page: Installation
+ path: docs/pages/get-started/installation.mdx
+ icon: fa-duotone fa-download
+ - page: Runtime Chooser
+ path: docs/pages/get-started/runtime-chooser.mdx
+ icon: fa-duotone fa-box
+ - section: By lifecycle stage
+ contents:
+ - page: Data
+ path: docs/pages/get-started/data.mdx
+ icon: fa-duotone fa-database
+ - page: Pretraining
+ path: docs/pages/get-started/pretraining.mdx
+ icon: fa-duotone fa-microchip
+ - page: RL
+ path: docs/pages/get-started/rl.mdx
+ icon: fa-duotone fa-arrows-rotate
+ - page: Inference
+ path: docs/pages/get-started/inference.mdx
+ icon: fa-duotone fa-gauge
+ - page: E2E
+ path: docs/pages/get-started/e2e.mdx
+ icon: fa-duotone fa-diagram-project
+ - section: Resources
+ path: docs/pages/resources/index.mdx
+ icon: fa-duotone fa-book-open
+ contents:
+ - page: Glossary
+ path: docs/pages/resources/glossary.mdx
+ icon: fa-duotone fa-book
+ - page: External Learning
+ path: docs/pages/resources/external-learning.mdx
+ icon: fa-duotone fa-arrow-up-right-from-square
+ - page: Community
+ path: docs/pages/resources/community.mdx
+ icon: fa-duotone fa-comments
diff --git a/fern/docs/pages/about/architecture.mdx b/fern/docs/pages/about/architecture.mdx
new file mode 100644
index 0000000..60411b5
--- /dev/null
+++ b/fern/docs/pages/about/architecture.mdx
@@ -0,0 +1,191 @@
+---
+title: Architecture
+subtitle: How NeMo OSS Libraries Fit Together
+slug: about/architecture
+position: 3
+---
+
+**NeMo OSS** is an ecosystem of focused repositories that you can use individually or together. Two named stacks organize those repos around common workflows:
+
+- **NeMo Framework** — the **model lifecycle** (data → train → align → evaluate → deploy).
+- **NeMo Platform** — **agent integration** (evaluate, secure, tune, and deploy agents using selected libraries).
+
+
+For positioning within NVIDIA NeMo, refer to [Ecosystem](/about/ecosystem). For the organizing model, refer to [Concepts](/about/concepts).
+
+
+## Three Layers
+
+The architecture is easiest to read as libraries, the Framework stack, and the Platform integration layer.
+
+| Layer | What it is | How you use it |
+| --- | --- | --- |
+| **Libraries** | 22 repos in [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo), each with its own source, releases, and docs | `pip install`, per-library docs, or standalone NGC images |
+| **NeMo Framework** | Model-lifecycle stack — the pipeline below | Pick libraries by stage, or pull the multi-library Framework container |
+| **NeMo Platform** | Agent product — CLI, SDK, Studio | Follow [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+
+```mermaid
+flowchart TB
+ subgraph oss ["NeMo OSS"]
+ LIBS["Libraries — à la carte"]
+ subgraph fw ["NeMo Framework — model lifecycle"]
+ PIPE["Data → Pretraining → RL → Inference"]
+ end
+ subgraph plat ["NeMo Platform — agents"]
+ PCLI["CLI · SDK · Studio"]
+ end
+ end
+
+ LIBS -.-> fw
+ PCLI -.-> PIPE
+```
+
+Platform **composes** libraries such as Guardrails, Evaluator, and Data Designer into agent workflows. For model training, start with Framework libraries such as AutoModel or Megatron-Bridge.
+
+## NeMo Framework Pipeline
+
+The diagram shows representative libraries. The live list is [Libraries](/about/libraries) filtered by stage.
+
+```mermaid
+flowchart LR
+ subgraph Data
+ Curator
+ DataDesigner[Data Designer]
+ end
+
+ subgraph Pretraining
+ AutoModel
+ MBridge[Megatron-Bridge]
+ Speech[NeMo Speech]
+ end
+
+ subgraph RL
+ NeMoRL[NeMo RL]
+ Gym[NeMo Gym]
+ end
+
+ subgraph Inference
+ Evaluator
+ Export[Export-Deploy]
+ Guardrails
+ end
+
+ subgraph E2E
+ Run[NeMo Run]
+ Skills
+ Nemotron
+ end
+
+ Data --> Pretraining
+ Pretraining --> RL
+ Pretraining --> Inference
+ RL --> Inference
+
+ Run -.-> Pretraining
+ Skills -.-> Data
+ Skills -.-> Inference
+```
+
+Solid arrows are the typical **model lifecycle**. Dotted lines are **orchestration and reference assets** (Run, Skills, Nemotron) that span stages.
+
+## Functional Layers
+
+Functional layers describe the role each stage plays in model development.
+
+| Layer | Purpose |
+| --- | --- |
+| **Data** | Ingest, filter, deduplicate, synthesize, and govern datasets |
+| **Pretraining** | Train, fine-tune, and convert checkpoints |
+| **RL** | Post-training alignment and agent improvement |
+| **Inference** | Benchmark, export, serve, and apply guardrails |
+| **E2E** | Launch experiments, ship recipes, share reference assets |
+
+Which repos sit in each layer changes over time — use [Libraries](/about/libraries) (filtered by stage) as the live catalog.
+
+## Training Backends
+
+Two primary training paths coexist:
+
+```mermaid
+flowchart TB
+ subgraph HF["PyTorch / Hugging Face path"]
+ AM[AutoModel]
+ RL1[NeMo RL]
+ end
+
+ subgraph MCore["Megatron-Core path"]
+ MB[Megatron-Bridge]
+ RL2[NeMo RL]
+ end
+
+ Data2[Curated data] --> AM
+ Data2 --> MB
+ AM --> RL1
+ MB --> RL2
+ RL1 --> Eval[Evaluator / Export-Deploy]
+ RL2 --> Eval
+```
+
+- **HF path** — `pip install nemo-automodel`, Hugging Face models and trainers, scales to roughly 1,000 GPUs.
+- **Megatron path** — Megatron-Bridge on Megatron-Core, HF checkpoint conversion, scales to thousand-node clusters.
+
+Both paths can feed the same **RL**, **Evaluator**, and **Export-Deploy** libraries downstream.
+
+## NeMo Platform Overlay
+
+[NeMo Platform](https://github.com/NVIDIA-NeMo/nemo-platform) integrates NeMo libraries for **agent** workflows. Use Framework libraries such as AutoModel, Megatron-Bridge, and NeMo RL for model training and alignment.
+
+| Platform capability | Libraries and services involved |
+| --- | --- |
+| Secure agents | Guardrails, Anonymizer, Auditor |
+| Evaluate agents | Evaluator, Harbor-backed suites |
+| Tune agents | Skill optimization, Switchyard routing |
+| Build agents | NeMo Agent Toolkit (NAT), Inference Gateway |
+| Synthetic data | Data Designer |
+
+Platform has its own CLI, SDK, and Studio experience. Refer to [Framework and Platform](/about/concepts/framework-and-platform) for naming and [Ecosystem](/about/ecosystem#choose-framework-or-platform) for when to start here.
+
+
+
+
+Setup, CLI reference, and API for agent hardening and evaluation.
+
+
+
+Model evaluation, export, guardrails, and Platform entry points.
+
+
+
+
+## NGC Containers
+
+NGC images bundle tested dependency sets for Framework libraries.
+
+| Image | Scope |
+| --- | --- |
+| `nvcr.io/nvidia/nemo` | Multi-library **Framework** stack (Megatron-Bridge, Evaluator, Export-Deploy, Run, Speech) |
+| `nvcr.io/nvidia/nemo-automodel` | Standalone AutoModel |
+| `nvcr.io/nvidia/nemo-rl` | Standalone NeMo RL |
+| `nvcr.io/nvidia/nemo-curator` | Standalone Curator |
+
+Refer to the [container catalog](/about/release-notes/containers) for pull commands and recent Framework tags.
+
+## Where to Go Next
+
+Use these pages when you are ready to choose an entry point or browse the catalog.
+
+
+
+
+How Framework, Platform, stages, libraries, and containers fit together.
+
+
+
+Install paths and stage-specific entry points.
+
+
+
+Full repo catalog with docs and GitHub links.
+
+
+
diff --git a/fern/docs/pages/about/concepts/containers-and-installs.mdx b/fern/docs/pages/about/concepts/containers-and-installs.mdx
new file mode 100644
index 0000000..7f3e9a8
--- /dev/null
+++ b/fern/docs/pages/about/concepts/containers-and-installs.mdx
@@ -0,0 +1,62 @@
+---
+title: Containers and Installs
+subtitle: Runtime Choices for NeMo OSS Workflows
+slug: about/concepts/containers-and-installs
+position: 5
+---
+
+NeMo OSS supports several runtime paths. Choose the path based on the workflow you want to run, then follow the linked library docs for current commands.
+
+## Runtime Choices
+
+Choose the runtime path that matches your workflow scope and development mode.
+
+| Runtime path | Use it for |
+| --- | --- |
+| **Framework container** | Multi-library workflows with `nvcr.io/nvidia/nemo:`. |
+| **Standalone containers** | Single-library workflows such as AutoModel, RL, or Curator. |
+| **Per-library installs** | Lightweight local development when a library recommends pip or source install. |
+| **Source checkout** | Contributing, debugging, or running examples that require repository files. |
+
+```mermaid
+flowchart TB
+ Goal["Workflow goal"] --> Multi["Cross-library Framework workflow"]
+ Goal --> Single["One library"]
+ Goal --> Dev["Local development"]
+ Multi --> FWC["Framework container"]
+ Single --> Standalone["Standalone container or library install"]
+ Dev --> Source["Source checkout"]
+```
+
+## Why Containers Cause Confusion
+
+The name **NeMo Framework** can mean the model-lifecycle stack or the `nvcr.io/nvidia/nemo` container. The container packages a tested set of components for selected Framework workflows. Standalone images and per-library installs remain the better fit for many single-library workflows.
+
+Standalone images exist for focused library workflows. Library docs cover extras, optional dependencies, local development, and release-specific compatibility.
+
+## Where to Check Versions
+
+Use the release or library page for details that change by version.
+
+| Need | Go to |
+| --- | --- |
+| Recent Framework container tags | [Container releases](/about/release-notes/containers) |
+| Cross-component Framework container known issues | [Known issues](/about/release-notes/known-issues) |
+| Library-specific install commands | The library docs linked from [Libraries](/about/libraries) |
+| GitHub source and issues | The repo linked from [Libraries](/about/libraries) |
+
+## Continue
+
+Use these pages when you are ready to turn runtime choice into setup steps.
+
+
+
+
+Compare the main setup paths.
+
+
+
+See Framework tags and component versions.
+
+
+
diff --git a/fern/docs/pages/about/concepts/documentation-surfaces.mdx b/fern/docs/pages/about/concepts/documentation-surfaces.mdx
new file mode 100644
index 0000000..7ae6d4f
--- /dev/null
+++ b/fern/docs/pages/about/concepts/documentation-surfaces.mdx
@@ -0,0 +1,53 @@
+---
+title: Where to Find Information
+subtitle: Setup, Releases, Examples, Terminology, and Support
+slug: about/concepts/documentation-surfaces
+position: 6
+---
+
+NeMo OSS information lives in a few places. Use this page to jump to the right source for the question you have.
+
+## Information Map
+
+Each source is best for a different kind of question.
+
+| Source | Use it for |
+| --- | --- |
+| **NeMo OSS Hub** | Choose a stack, library, stage, or container. |
+| **Get Started** | Start by task, lifecycle stage, or runtime. |
+| **Library Docs** | Learn install details, APIs, tutorials, configuration, examples, and current support. |
+| **Release Notes** | Check Framework container tags, component versions, and cross-component known issues. |
+| **GitHub** | Read source, file issues, open PRs, and follow contribution instructions. |
+| **Glossary** | Look up terms, acronyms, and product names. |
+| **External Learning** | Find community writeups and videos, then verify current steps in library docs. |
+
+## Quick Routing
+
+Use the first form of your question to choose a starting point.
+
+| If your question starts with... | Start here |
+| --- | --- |
+| "Which NeMo repo should I use?" | [Libraries](/about/libraries) |
+| "I know the task, not the repo name." | [Task map](/get-started/task-map) |
+| "Do I need Framework or Platform?" | [Framework and Platform](/about/concepts/framework-and-platform) |
+| "Which stage am I in?" | [Lifecycle stages](/about/concepts/lifecycle-stages) |
+| "Which container or install path?" | [Containers and installs](/about/concepts/containers-and-installs) |
+| "What does this term mean?" | [Glossary](/resources/glossary) |
+| "Has someone written or recorded an example?" | [External learning](/resources/external-learning) |
+| "How do I run this exact example?" | The linked library docs or GitHub repo |
+
+## Continue
+
+Use these resources when your next step is lookup, community context, or examples.
+
+
+
+
+Community links, glossary, releases, and support entry points.
+
+
+
+Look up product names, repo roles, and common terms.
+
+
+
diff --git a/fern/docs/pages/about/concepts/framework-and-platform.mdx b/fern/docs/pages/about/concepts/framework-and-platform.mdx
new file mode 100644
index 0000000..c69a8f5
--- /dev/null
+++ b/fern/docs/pages/about/concepts/framework-and-platform.mdx
@@ -0,0 +1,79 @@
+---
+title: Framework and Platform
+subtitle: Two Adoption Paths for Model and Agent Work
+slug: about/concepts/framework-and-platform
+position: 1
+---
+
+Most NeMo OSS users start from one of two paths: **NeMo Framework** for model lifecycle work, or **NeMo Platform** for integrated agent workflows. They share libraries, but they answer different developer questions.
+
+## The Main Distinction
+
+Choose the path based on whether your work centers on models or integrated agents.
+
+| Your goal | Start with | Why |
+| --- | --- | --- |
+| Train, fine-tune, align, evaluate, export, or deploy **models** | **NeMo Framework** | It organizes libraries around the model lifecycle from data through deployment. |
+| Evaluate, secure, tune, or deploy **agents** | **NeMo Platform** | It composes selected libraries behind a CLI, SDK, and Studio UI for agent workflows. |
+| Explore before choosing | [Libraries](/about/libraries) | The catalog lets you filter by stage, kind, and tags. |
+
+**NeMo Framework** is the model-lifecycle stack: data, training, RL, evaluation, export, and guardrails. It is also the name of the multi-library NGC image (`nvcr.io/nvidia/nemo:`). When the distinction matters, these docs use **Framework libraries** for the stack and **Framework container** for the image.
+
+**NeMo Platform** is the agent integration product in the [nemo-platform](https://github.com/NVIDIA-NeMo/nemo-platform) repo. It brings together libraries such as Guardrails, Evaluator, and Data Designer for agent use cases.
+
+```mermaid
+flowchart TB
+ subgraph Framework["NeMo Framework - model lifecycle"]
+ Data["Data"]
+ Train["Pretraining"]
+ Align["RL"]
+ Deploy["Inference"]
+ Data --> Train --> Align --> Deploy
+ end
+
+ subgraph Platform["NeMo Platform - agent workflows"]
+ CLI["CLI"]
+ SDK["SDK"]
+ Studio["Studio"]
+ end
+
+ Platform -. uses .-> Deploy
+ Platform -. uses .-> Data
+```
+
+## When the Paths Meet
+
+The two paths often meet downstream. A team might curate data with Curator, train with AutoModel or Megatron-Bridge, align with NeMo RL, benchmark with Evaluator, and then use Platform when the output becomes part of an agent workflow.
+
+Framework describes the model pipeline. Platform describes an integrated agent experience built from selected pieces of that pipeline.
+
+## Common Naming Traps
+
+These names are close enough that readers often need a quick disambiguation.
+
+| Name | Meaning |
+| --- | --- |
+| **NeMo OSS** | The GitHub organization, documentation, and related OSS containers. |
+| **NeMo Framework** | Model lifecycle libraries and, in container contexts, the `nvcr.io/nvidia/nemo` image. |
+| **NeMo Platform** | Agent integration product with CLI, SDK, and Studio. |
+| **NeMo Speech** | Speech AI docs and source in the `NVIDIA-NeMo/NeMo` repo. |
+
+## Continue
+
+Use these pages when you need broader positioning or structural context.
+
+
+
+
+Follow the model pipeline from data through inference.
+
+
+
+See how OSS, Platform, and the broader NVIDIA NeMo suite relate.
+
+
+
+See the structural diagram and library layers.
+
+
+
diff --git a/fern/docs/pages/about/concepts/index.mdx b/fern/docs/pages/about/concepts/index.mdx
new file mode 100644
index 0000000..9283925
--- /dev/null
+++ b/fern/docs/pages/about/concepts/index.mdx
@@ -0,0 +1,104 @@
+---
+title: Concepts
+subtitle: Mental Models for Working Across NeMo OSS
+slug: about/concepts
+position: 4
+---
+
+Use these pages to understand how **NeMo OSS** is organized: how repos are grouped, how workflows move across libraries, and how containers relate to install paths.
+
+For short term definitions and acronyms, use the [Glossary](/resources/glossary).
+
+## Concept Map
+
+NeMo OSS is the public open source side of NVIDIA NeMo: repositories in [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo), library documentation, and the NGC containers that package common runtime paths.
+
+Use this site to choose a stack, stage, library, or container, then follow the linked library docs for usage details.
+
+```mermaid
+flowchart TB
+ Hub["NeMo OSS"]
+ Catalog["Libraries"]
+ Framework["NeMo Framework\nmodel lifecycle"]
+ Platform["NeMo Platform\nagent workflows"]
+ LibraryDocs["Library docs"]
+ Repos["GitHub"]
+ Containers["NGC containers"]
+
+ Hub --> Catalog
+ Catalog --> Framework
+ Catalog --> Platform
+ Framework --> LibraryDocs
+ Platform --> LibraryDocs
+ LibraryDocs --> Repos
+ Framework --> Containers
+```
+
+NeMo OSS is one part of the broader [NVIDIA NeMo](https://www.nvidia.com/en-us/ai-data-science/products/nemo/) software suite, alongside commercial products such as Customizer, NIM, and NeMo microservices.
+
+## Pages
+
+These concept pages split the main mental model into focused explanations.
+
+
+
+
+Choose between the model-lifecycle stack and the agent integration product.
+
+
+
+Understand Data, Pretraining, RL, Inference, and E2E as workflow stages.
+
+
+
+Read stage, kind, and tags without treating repo placement as a rigid boundary.
+
+
+
+Compare the PyTorch / Hugging Face and Megatron-Core paths, including checkpoint flow.
+
+
+
+Choose between Framework containers, standalone images, and per-library installs.
+
+
+
+Choose the right page for setup, releases, examples, terminology, and support.
+
+
+
+
+## What These Pages Clarify
+
+Use the Concepts section when you need durable context before following a library-specific guide:
+
+| Question | Concept response |
+| --- | --- |
+| Which name, stack, repo, or container should I start with? | [Framework and Platform](/about/concepts/framework-and-platform), [Containers and installs](/about/concepts/containers-and-installs) |
+| How do workflows move across libraries and stages? | [Lifecycle stages](/about/concepts/lifecycle-stages), [Repository catalog model](/about/concepts/repository-catalog) |
+| How do training backend and checkpoint choices affect downstream work? | [Training backends and checkpoints](/about/concepts/training-backends-and-checkpoints) |
+| Where should I go for setup, releases, examples, or support? | [Where to find information](/about/concepts/documentation-surfaces) |
+
+## Related Pages
+
+These pages provide the surrounding orientation, structure, catalog, and terminology.
+
+
+
+
+Choose Framework, Platform, or broader NVIDIA NeMo entry points.
+
+
+
+See the layers, pipeline diagram, backends, and containers.
+
+
+
+Search and filter all open source repos.
+
+
+
+Look up terms, acronyms, and product names.
+
+
+
diff --git a/fern/docs/pages/about/concepts/lifecycle-stages.mdx b/fern/docs/pages/about/concepts/lifecycle-stages.mdx
new file mode 100644
index 0000000..d00b357
--- /dev/null
+++ b/fern/docs/pages/about/concepts/lifecycle-stages.mdx
@@ -0,0 +1,66 @@
+---
+title: Lifecycle Stages
+subtitle: How NeMo Framework Groups Model Work
+slug: about/concepts/lifecycle-stages
+position: 2
+---
+
+NeMo Framework groups libraries by the stage of model development they usually support. Stages help you find the right entry point, especially when a workflow spans several repos.
+
+## Stage Model
+
+Stages describe the usual position of each library in the model lifecycle.
+
+| Stage | You typically... | Examples |
+| --- | --- | --- |
+| **Data** | Curate, filter, synthesize, anonymize, or govern datasets | Curator, Data Designer, Anonymizer |
+| **Pretraining** | Pretrain, fine-tune, adapt models, or convert training formats | AutoModel, Megatron-Bridge, NeMo Speech |
+| **RL** | Align models with SFT, DPO, GRPO, distillation, or reinforcement learning | NeMo RL, Gym, ProRL Agent Server |
+| **Inference** | Evaluate quality, export checkpoints, deploy, or add guardrails | Evaluator, Export-Deploy, Guardrails |
+| **E2E** | Run multi-step recipes, orchestrate experiments, or share reference pipelines | Run, Skills, Nemotron |
+
+```mermaid
+flowchart LR
+ Data["Data"] --> Pretraining["Pretraining"]
+ Pretraining --> RL["RL"]
+ RL --> Inference["Inference"]
+ Pretraining --> Inference
+ E2E["E2E recipes and orchestration"] -. spans .-> Data
+ E2E -. spans .-> Pretraining
+ E2E -. spans .-> RL
+ E2E -. spans .-> Inference
+```
+
+The arrows show a common model lifecycle, not a required sequence. You can use Evaluator without training a model in NeMo, or use Curator for data that feeds a non-NeMo training stack.
+
+## Stage Guides and Cross-Stage Work
+
+Use stage guides when you know the part of the lifecycle you are working on:
+
+- [Data](/get-started/data)
+- [Pretraining](/get-started/pretraining)
+- [RL](/get-started/rl)
+- [Inference](/get-started/inference)
+- [E2E](/get-started/e2e)
+
+Use [Libraries](/about/libraries) when your work crosses stages. Agent evaluation, deployment, speech, and checkpoint conversion often involve several repos even when one repo is the main starting point.
+
+## What Stays Stable
+
+Stage pages help you choose an entry point. For supported models, commands, and detailed recipes, follow the linked library docs.
+
+## Continue
+
+Use these pages when you need to connect stage selection to repo selection or training flow.
+
+
+
+
+Learn how stage, kind, and tags work together.
+
+
+
+Choose a training path and understand checkpoint flow.
+
+
+
diff --git a/fern/docs/pages/about/concepts/repository-catalog.mdx b/fern/docs/pages/about/concepts/repository-catalog.mdx
new file mode 100644
index 0000000..5395c83
--- /dev/null
+++ b/fern/docs/pages/about/concepts/repository-catalog.mdx
@@ -0,0 +1,63 @@
+---
+title: Repository Catalog Model
+subtitle: How Stage, Kind, and Tags Describe Each Repo
+slug: about/concepts/repository-catalog
+position: 3
+---
+
+The [Libraries](/about/libraries) catalog uses three signals to describe each GitHub repo: **stage**, **kind**, and **tags**. Together, they answer where a repo fits, what role it plays, and which cross-cutting workflows it supports.
+
+## Three Catalog Signals
+
+The catalog uses three signals so a repo can be found by lifecycle position, adoption role, and cross-cutting topic.
+
+| Signal | What it answers | Example |
+| --- | --- | --- |
+| **Stage** | Where the repo usually sits in the lifecycle | Data, Pretraining, RL, Inference, E2E |
+| **Kind** | The role the repo plays | Library, integration, reference, infrastructure |
+| **Tags** | Cross-cutting concerns | `speech`, `evaluation`, `agents`, `deployment` |
+
+Stages match the NVIDIA-NeMo org README columns. Kind keeps the catalog honest when stage alone would be misleading. Tags help users find workflows that do not fit neatly in one lifecycle stage.
+
+## Kind
+
+Kind explains the adoption role of a repo when stage alone is too broad.
+
+| Kind | Role | Examples |
+| --- | --- | --- |
+| **Library** | Focused product for a lifecycle stage | Curator, AutoModel, RL, Evaluator |
+| **Integration** | Composes libraries into one product surface | NeMo Platform |
+| **Reference** | Recipes, cookbooks, datasets, and example pipelines | Skills, Nemotron |
+| **Infrastructure** | Shared project infrastructure | FW-CI-templates |
+
+For example, Platform appears under Inference because agent builders often arrive through evaluation, guardrails, and deployment. Its kind still tells you that it is an integration product.
+
+## Tags
+
+Tags are search facets, not a second taxonomy. They help connect repos by theme:
+
+| Tag theme | Why it helps |
+| --- | --- |
+| **Modality** | Find speech, vision-language, tabular, or multimodal work. |
+| **Technique** | Find GRPO, DPO, synthetic data, curation, or checkpoint conversion work. |
+| **Role** | Find evaluation, deployment, guardrails, agents, privacy, or orchestration work. |
+
+## When Repo Placement Looks Surprising
+
+Some repos support more than one stage. The catalog places each repo where most readers are likely to begin, then uses kind and tags to show its broader role.
+
+## Continue
+
+Use these pages when you need to move from repo placement to a specific next step.
+
+
+
+
+Search and filter the live catalog.
+
+
+
+Find setup, releases, examples, terminology, and support links.
+
+
+
diff --git a/fern/docs/pages/about/concepts/training-backends-and-checkpoints.mdx b/fern/docs/pages/about/concepts/training-backends-and-checkpoints.mdx
new file mode 100644
index 0000000..6a6a72a
--- /dev/null
+++ b/fern/docs/pages/about/concepts/training-backends-and-checkpoints.mdx
@@ -0,0 +1,62 @@
+---
+title: Training Backends and Checkpoints
+subtitle: How the Main Training Paths Connect Downstream
+slug: about/concepts/training-backends-and-checkpoints
+position: 4
+---
+
+NeMo Framework supports two primary training paths. The right path depends on your scale, source model format, and checkpoint flow.
+
+## Two Training Paths
+
+Choose the training path based on scale, source model format, and downstream checkpoint needs.
+
+| Path | Start with | Typical fit |
+| --- | --- | --- |
+| **PyTorch / Hugging Face** | [AutoModel](https://docs.nvidia.com/nemo/automodel/latest/) | Fine-tuning, research iteration, and training up to roughly 1,000 GPUs. |
+| **Megatron-Core** | [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/) | Large-scale pretraining, SFT, and Hugging Face to Megatron checkpoint conversion. |
+
+Both paths can feed downstream RL, evaluation, and export workflows.
+
+```mermaid
+flowchart TB
+ Data["Curated data"] --> AM["AutoModel\nPyTorch / HF"]
+ Data --> MB["Megatron-Bridge\nMegatron-Core"]
+ AM --> RL["NeMo RL"]
+ MB --> RL
+ AM --> Eval["Evaluator"]
+ MB --> Eval
+ RL --> Eval
+ Eval --> Export["Export-Deploy"]
+```
+
+## Checkpoint Flow
+
+Checkpoint format affects the rest of the workflow. Check whether downstream RL, evaluation, or deployment expects Hugging Face, Megatron, NeMo, or another serving format before choosing a training path.
+
+| Question | Good next page |
+| --- | --- |
+| Which training library should I start with? | [Pretraining guide](/get-started/pretraining) |
+| How do I convert between Hugging Face and Megatron checkpoints? | [Megatron-Bridge docs](https://docs.nvidia.com/nemo/megatron-bridge/latest/) |
+| Can my trained model run through RL or evaluation? | [RL guide](/get-started/rl), [Inference guide](/get-started/inference) |
+| How do I export or serve a model? | [Export-Deploy docs](https://docs.nvidia.com/nemo/export-deploy/latest/) |
+
+## Next Step
+
+After choosing a path, use the linked library docs for model support, conversion scripts, commands, and compatibility notes.
+
+## Continue
+
+Use these pages when you are ready to choose a training entry point or runtime.
+
+
+
+
+Choose AutoModel, Megatron-Bridge, NeMo Speech, or optimizer libraries.
+
+
+
+Choose a runtime path before running examples.
+
+
+
diff --git a/fern/docs/pages/about/ecosystem.mdx b/fern/docs/pages/about/ecosystem.mdx
new file mode 100644
index 0000000..9d3cebc
--- /dev/null
+++ b/fern/docs/pages/about/ecosystem.mdx
@@ -0,0 +1,133 @@
+---
+title: Ecosystem
+subtitle: NeMo OSS Within the NVIDIA NeMo Software Suite
+slug: about/ecosystem
+position: 2
+---
+
+**NeMo OSS** is the public, open source entry point for [NVIDIA NeMo](https://www.nvidia.com/en-us/ai-data-science/products/nemo/): the [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo) GitHub organization, and the libraries and containers that support model and agent development.
+
+
+This page explains **where NeMo OSS fits** and **what to choose**. For the organizing model, refer to [Concepts](/about/concepts). For structure, refer to [Architecture](/about/architecture).
+
+
+## What You Can Build
+
+NeMo OSS is organized around two adoption paths:
+
+```mermaid
+flowchart TB
+ subgraph nemooss ["NeMo OSS"]
+ subgraph framework ["NeMo Framework — models"]
+ STAGES["Data · Pretraining · RL · Inference · E2E"]
+ end
+ subgraph platform ["NeMo Platform — agents"]
+ AGENT["CLI · SDK · Studio"]
+ end
+ REPOS["22 catalog repos"]
+ end
+ COMM["Commercial NVIDIA NeMo"]
+
+ REPOS --> framework
+ AGENT --> REPOS
+ nemooss -.-> COMM
+```
+
+| You are building… | Start with… |
+| --- | --- |
+| **Models** (train, align, evaluate, deploy checkpoints) | **NeMo Framework** — libraries by stage or Framework NGC container |
+| **Agents** (evaluate, secure, tune, deploy in production) | **NeMo Platform** — or individual inference libraries à la carte |
+| **Not sure yet** | [Libraries](/about/libraries) catalog or [decision guide](/get-started#decision-guide) |
+
+## Framework Lifecycle Stages
+
+NeMo Framework delivers the model pipeline as composable open source libraries:
+
+| Stage | Role in the pipeline |
+| --- | --- |
+| **[Data](/get-started/data)** | Prepare and govern training data |
+| **[Pretraining](/get-started/pretraining)** | Train and fine-tune models |
+| **[RL](/get-started/rl)** | Align and improve models with feedback |
+| **[Inference](/get-started/inference)** | Evaluate, export, and safeguard models |
+| **[E2E](/get-started/e2e)** | Recipes, orchestration, reference assets |
+
+Repo names and counts change — [Libraries](/about/libraries) is the searchable catalog. Each library's docs site has install steps and tutorials.
+
+## Choose Framework or Platform
+
+These names sound similar because they share libraries, but they serve different developer jobs:
+
+| | **NeMo Framework** | **NeMo Platform** |
+| --- | --- | --- |
+| **What it is** | Model-lifecycle **libraries** — data, training, RL, evaluation, export, guardrails | Agent **integration product** — CLI, Python SDK, and web UI |
+| **You adopt it when…** | You are training, aligning, evaluating, or deploying **models** | You are shipping **agents** and want evaluate / secure / tune / deploy in one setup |
+| **Typical entry** | Stage guide → library docs, or Framework NGC container | Follow [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+| **Docs** | NeMo OSS pages and library docs | [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+| **Relationship** | Libraries are the building blocks | Composes Guardrails, Evaluator, Data Designer, and others for agent workflows |
+
+**NeMo Framework** also names the multi-library NGC container (`nvcr.io/nvidia/nemo`). Refer to [Framework and Platform](/about/concepts/framework-and-platform) for naming details.
+
+Many teams train with **AutoModel or Megatron-Bridge**, align with **NeMo RL**, benchmark with **Evaluator**, and serve with **Export-Deploy**. Agent builders can start from **NeMo Platform** instead of wiring those pieces manually.
+
+## Open Source and Commercial Entry Points
+
+NeMo OSS focuses on open source repositories, OSS documentation, and Framework container releases. The broader NVIDIA NeMo suite also includes commercial products, enterprise services, and NIM microservices with their own product documentation.
+
+| NeMo OSS | Broader NVIDIA NeMo Docs |
+| --- | --- |
+| 22 public GitHub repos in NVIDIA-NeMo | Customizer, NIM, enterprise services |
+| Framework container release notes | Per-tenant managed offerings |
+| Open source hub and library documentation | Product documentation for commercial offerings |
+
+For the full suite, refer to [NVIDIA NeMo (commercial)](https://www.nvidia.com/en-us/ai-data-science/products/nemo/).
+
+## OSS and Product Docs
+
+Use this comparison to choose between open source entry points and product documentation.
+
+| | **NeMo OSS** | **Library docs** |
+| --- | --- | --- |
+| **Audience** | Choose a stack, stage, or library | Use one library or product deeply |
+| **Content** | Catalog, get-started paths, release notes | APIs, tutorials, recipes |
+| **Scope** | Orientation across NeMo OSS | One library or Platform at a time |
+
+## Choosing AutoModel or Megatron-Bridge
+
+Both train large language models (LLMs) and vision language models (VLMs) on NVIDIA GPUs; they target different scale and stack preferences:
+
+| | **AutoModel** | **Megatron-Bridge** |
+| --- | --- | --- |
+| **Stack** | PyTorch / Hugging Face native | Megatron-Core |
+| **Typical scale** | 1–1,000 GPUs | 1,000+ GPUs |
+| **Checkpoint flow** | Hugging Face checkpoints | HF ↔ Megatron conversion |
+| **Best for** | Fine-tuning, research, rapid iteration | Large-scale pretraining and SFT |
+
+Speech workloads often start with [NeMo Speech](https://docs.nvidia.com/nemo/speech/nightly/) directly — the [NeMo](https://github.com/NVIDIA-NeMo/NeMo) repo is speech-only today.
+
+## Related Entry Points
+
+Use these links to move from ecosystem positioning to concepts, structure, catalog, and setup.
+
+
+
+
+How NeMo OSS organizes stacks, stages, libraries, and docs.
+
+
+
+Three layers, pipeline, backends, containers.
+
+
+
+Search and filter all 22 NVIDIA-NeMo repositories.
+
+
+
+Quickstart, installation, and guides by stage.
+
+
+
+Agent evaluate, harden, tune, and deploy — CLI, SDK, and Studio.
+
+
+
diff --git a/fern/docs/pages/about/libraries.mdx b/fern/docs/pages/about/libraries.mdx
new file mode 100644
index 0000000..9cce256
--- /dev/null
+++ b/fern/docs/pages/about/libraries.mdx
@@ -0,0 +1,65 @@
+---
+title: Libraries
+subtitle: Open Source Libraries in the NVIDIA-NeMo GitHub Organization
+slug: about/libraries
+position: 5
+---
+
+import RepoCatalog from "@/components/RepoCatalog";
+
+Browse **22 open source repositories** in [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo). Most are **NeMo Framework** libraries for the model lifecycle; [NeMo Platform](https://github.com/NVIDIA-NeMo/nemo-platform) composes several libraries into an agent integration experience.
+
+For positioning, refer to [Ecosystem](/about/ecosystem). For pipeline structure, refer to [Architecture](/about/architecture).
+
+## Common Routes
+
+Use these routes when you know the work you want to do before you know the repo name.
+
+
+
+
+Curator, Data Designer, Anonymizer, Safe-Synthesizer, and Skills.
+
+
+
+AutoModel for PyTorch / Hugging Face workflows, Megatron-Bridge for Megatron-Core scale.
+
+
+
+NeMo RL, Gym, and ProRL Agent Server.
+
+
+
+Evaluator, Guardrails, Export-Deploy, and NeMo Platform.
+
+
+
+Framework container, standalone container, pip/source install, or Platform setup.
+
+
+
+
+
+
+## How Repos Are Grouped
+
+Each card shows a **stage** and a **kind**:
+
+| Kind | Role | Examples |
+| --- | --- | --- |
+| **Library** | Focused product for a stage | Curator, AutoModel, RL, Evaluator |
+| **Integration** | Composes libraries into one product | NeMo Platform |
+| **Reference** | Recipes, cookbooks, pipelines | Skills, Nemotron |
+| **Infrastructure** | Shared project infrastructure | FW-CI-templates |
+
+| Stage | What lives here |
+| --- | --- |
+| **Data** | Curation, synthetic data, PII handling, SDG pipelines |
+| **Pretraining** | Model training and fine-tuning (AutoModel, Megatron-Bridge, NeMo Speech, optimizers) |
+| **RL** | Post-training alignment, environments, agent rollout |
+| **Inference** | Evaluation, export, serving, guardrails (and Platform for agent integration) |
+| **E2E** | Reference pipelines, recipes, experiment orchestration |
+
+Use **tags** on each card (or the search box) for cross-cutting facets like `speech`, `evaluation`, or `agents`.
+
+Some cards link directly to library docs; others link to the best available README or product documentation. Speech AI documentation is at [NeMo Speech](https://docs.nvidia.com/nemo/speech/nightly/).
diff --git a/fern/docs/pages/about/release-notes/containers.mdx b/fern/docs/pages/about/release-notes/containers.mdx
new file mode 100644
index 0000000..69c68da
--- /dev/null
+++ b/fern/docs/pages/about/release-notes/containers.mdx
@@ -0,0 +1,14 @@
+---
+title: Container Releases
+subtitle: NGC Container Announcements and Version Metadata
+slug: about/release-notes/containers
+position: 2
+---
+
+import ContainerCatalog from "@/components/ContainerCatalog";
+
+NGC containers bundle tested versions of NeMo libraries for training, alignment, evaluation, and deployment. Use the catalog below to compare images, filter by type or lifecycle stage, and pull the right container for your workload.
+
+Refer to the [release notes overview](/about/release-notes) for release links, and [known issues](/about/release-notes/known-issues) for cross-component problems on Framework releases.
+
+
diff --git a/fern/docs/pages/about/release-notes/index.mdx b/fern/docs/pages/about/release-notes/index.mdx
new file mode 100644
index 0000000..9b5ed48
--- /dev/null
+++ b/fern/docs/pages/about/release-notes/index.mdx
@@ -0,0 +1,42 @@
+---
+title: Release Notes
+subtitle: Version History and Release Information for NeMo OSS
+slug: about/release-notes
+position: 1
+---
+
+Release notes and version history for **NeMo OSS** — open source libraries in [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo) on GitHub.
+
+This section publishes **NeMo Framework container** announcements. Library-specific release notes and docs are linked from [Libraries](/about/libraries).
+
+
+
+
+Latest NGC tags, pull commands, component versions, and release history links.
+
+
+
+Cross-component container issues by release tag.
+
+
+
+Search all 22 repos — each card links to docs, GitHub, and release notes.
+
+
+
+
+## Release Metadata
+
+Use these links when you need component versions or cross-component issue notes for a Framework container release.
+
+
+
+
+PyTorch, Megatron-Core, Transformer Engine, and bundled library versions per container — canonical for 26.02+.
+
+
+
+Cross-component container issues by release tag.
+
+
+
diff --git a/fern/docs/pages/about/release-notes/known-issues.mdx b/fern/docs/pages/about/release-notes/known-issues.mdx
new file mode 100644
index 0000000..c766a8b
--- /dev/null
+++ b/fern/docs/pages/about/release-notes/known-issues.mdx
@@ -0,0 +1,167 @@
+---
+title: Known Issues
+subtitle: Cross-Component Issues for NeMo Framework Containers
+slug: about/release-notes/known-issues
+position: 3
+---
+
+Known issues for **NeMo Framework** NGC containers (`nvcr.io/nvidia/nemo`). Find your container tag on [Container releases](/about/release-notes/containers), then check the matching section below.
+
+
+
+
+Recent container tags and bundled component versions.
+
+
+
+Pinned package versions for 26.02+ containers.
+
+
+
+
+## 26.02
+
+See component release notes for library-specific known issues:
+
+- [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/)
+- [Export-Deploy](https://docs.nvidia.com/nemo/export-deploy/latest/)
+- [Run](https://docs.nvidia.com/nemo/run/latest/)
+- [NeMo Speech](https://docs.nvidia.com/nemo/speech/nightly/)
+
+## 25.11
+
+See component release notes for library-specific known issues:
+
+- [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/)
+- [Export-Deploy](https://docs.nvidia.com/nemo/export-deploy/latest/)
+- [Run](https://docs.nvidia.com/nemo/run/latest/)
+- [NeMo Speech](https://docs.nvidia.com/nemo/speech/nightly/)
+
+## 25.09
+
+The following issues apply to the 25.09 Framework container release.
+
+### AutoModel
+
+These notes apply to AutoModel workflows in this release.
+
+- Knowledge distillation validation has a known issue. Set `--step_scheduler.val_every_steps=9223372036854775807` to bypass the issue.
+
+### Megatron-Bridge
+
+These notes apply to Megatron-Bridge workflows in this release.
+
+- Pretraining DeepSeek in subchannel FP8 precision is not working. Pretraining DeepSeek with current scaling FP8 is a workaround, but MTP loss does not converge.
+
+## 25.07
+
+The following issues apply to the 25.07 Framework container release.
+
+- DeepSeek model pretraining has a memory spike at the end of training, after the validation loop and checkpoint saving. The memory spike is linked to the cross-entropy layer. This may lead to an NCCL error at the end of training.
+- When fine-tuning with CP > 1, you might need to set `calculate_per_token_loss = True` for some cases. It depends on the dataset you choose. Note that this will result in slightly different loss from before, but both will lead to model convergence.
+- TensorRT-LLM has to be installed in order to run the ONNX export tutorial for LLM embedding models in the Finetuning Llama 3.2 Model into Embedding Model tutorial. Use the [Export-Deploy install instructions](https://github.com/NVIDIA-NeMo/Export-Deploy).
+- Exporting with ONNX requires `transformers` v4.51. By default, the container comes with v4.53. Consider downgrading with `uv pip install transformers==4.51.0`. For use cases outside the container, use `pip install transformers==4.51.0`.
+- Distributed checkpoint saving fails for Nemotron-h 47B and 56B on GB200. No issues observed on H100 or B200.
+
+## 25.04.02 and 25.04.01
+
+The following issues apply to the 25.04.02 and 25.04.01 Framework container releases.
+
+- **Tensor-Parallel Communication Overlap:** Functional errors may occur with specific tensor-parallel communication overlap configurations, including AllGather+GEMM overlap and the ring-exchange algorithm when `aggregate=True`.
+- **LayerNorm Bias Accuracy:** Training models using LayerNorm with bias (e.g., StarCoder2) might exhibit accuracy issues. A fix is available in TransformerEngine commit 1569. This fix is not yet included in the current NeMo release container. **Workaround:** Manually mount or pip install the latest TransformerEngine version in your container.
+- **Large Model Checkpoint NaN Errors (T5 11B, StarCoder2 7B):** Loading trained checkpoints for fine-tuning T5 (11B) and StarCoder2 (7B) models may result in NaN values. This is suspected to be a checkpoint saving/loading error. A potential fix is in Megatron Core PR 48cc46f. This fix is currently under testing.
+- **MXFP8 Memory Usage:** MXFP8 is currently using more memory than expected. A fix is in progress.
+- **FP8 in AutoModel Workflow:** Using FP8 in the AutoModel workflow requires manually setting `use_linear_ce_loss` to `False`. Alternatively, upgrade NeMo to commit `64f0fa`. FP8 support for Mixture of Experts (MoE) models is planned for a future release.
+- **HF Export for Llama-3_3-Nemotron-Super-49B-v1:** Hugging Face export is not currently supported for the Llama-3_3-Nemotron-Super-49B-v1 model.
+
+## 25.04.00
+
+The following issues apply to the 25.04.00 Framework container release.
+
+- Llama 4 accuracy may degrade slightly due to an issue with the order of sigmoid application in the expert routing logic. This has been fixed in [Megatron-LM](https://github.com/NVIDIA/Megatron-LM). However, the fix is not yet included in the current NeMo release container. To apply the fix, manually mount the updated Megatron Core source when building or running your container.
+- Resuming from local checkpoints using the `get_global_step_from_global_checkpoint_path` utility function may face challenges with auto-inserted metrics in the path. This is fixed in [NeMo#13012](https://github.com/NVIDIA/NeMo/pull/13012). However, the fix is not yet included in the current NeMo release container.
+- Tensor-parallel communication overlap with AllGather+GEMM overlap and the ring-exchange algorithm with `aggregate=True` may have functional errors.
+- In `scripts/vlm/automodel.py`, the `gbs` argument is a string instead of an integer. Additionally, this script needs to be run via `torchrun` for devices > 1.
+- There might be accuracy issues when training models that use LayerNorm with bias (e.g., StarCoder2). This issue has been addressed in [TransformerEngine](https://github.com/NVIDIA/TransformerEngine). However, the fix is not yet included in the current NeMo release container. **Workaround:** Manually mount or pip install the latest TransformerEngine in your container.
+- T5 and StarCoder for large config models (11B for T5, 7B for StarCoder2) may get NaN values when loading trained checkpoints for fine-tuning. We suspect a checkpoint saving/loading error, which is supposed to be fixed with a recent Megatron Core PR. Currently we are testing this fix.
+- MXFP8 currently uses more memory than expected and we are still fixing it.
+- FP8 in the AutoModel workflow requires setting `use_linear_ce_loss` to `False` manually, or upgrading NeMo to commit `64f0fa`. FP8 support for MoE models is scheduled for a future release.
+- No HF export support for Llama-3_3-Nemotron-Super-49B-v1.
+
+## 25.02
+
+The following issues apply to the 25.02 Framework container release.
+
+### AutoModel
+
+These notes apply to AutoModel workflows in this release.
+
+- Primarily a functional release; performance improvements are planned for future versions.
+- For large models (e.g., > 40B) trained with FSDP2, checkpoint saving can take longer than expected.
+- Support for long sequences is currently limited, especially for large models > 30B.
+- Models with external dependencies may fail to run if dependencies are unavailable (e.g., missing package leading to failed import).
+- A small percentage of models available via `AutoModelForCausalLM` may only support inference, and have training capabilities explicitly disabled.
+- Support for FSDP2 with mixed weights models (e.g. FP8 + BF16) is scheduled for future releases.
+- Support for Context Parallelism with sequence packing + padding between sequences is currently broken (see [NeMo#12174](https://github.com/NVIDIA/NeMo/issues/12174)). Use 24.12 or upgrade to TE 2.0+ for working support.
+- MoE based models are seeing instability with training. Please continue to use 24.12 for MoE training until 25.02 is patched with the fix for MoE.
+
+## 24.12 and Earlier
+
+The following issues apply to 24.12 and earlier Framework container releases.
+
+### Framework and Training
+
+These notes apply to framework-level training behavior in older releases.
+
+- In 24.12, NeMo switched from `pytorch_lightning` to `lightning.pytorch`. If you have custom code that imports `pytorch_lightning`, replace the import with `lightning.pytorch`. Failing to do so results in `ValueError: Expected a parent`.
+- When using a 24.12 container or later with LM Evaluation Harness, upgrade LM Evaluation Harness to include the required commit. Otherwise you may see `ValueError: You selected an invalid strategy name...`.
+- Restoring model context for NeMo 2.0 checkpoints produced using the NeMo 24.09 container fails when building `OptimizerConfig` from `megatron.core.optimizer.optimizer_config`, as `overlap_grad_reduce` and `overlap_param_gather` were moved in Megatron Core. The `update_io_context.py` script drops unknown parameters from the checkpoint context to make it compatible with the latest container.
+- Griffin's (NeMo 1.0) full fine-tuning has checkpoint loading issues; the state dicts do not match between the provided checkpoint and the initialized model. Use the 24.07 container if this model is needed.
+- Pretrain Gemma 2 27b recipe needs at least 2 nodes; currently the recipe has the default number of nodes set to 1.
+- The Megatron Core Distributed Optimizer currently lacks memory capacity optimization, resulting in higher model state memory usage at small data parallel sizes.
+- The overlap of the data-parallel parameter AllGather with `optimizer.step` (`overlap_param_gather_with_optimizer=true`) does not work with distributed checkpointing.
+- Support for converting models from NeMo 2.0 to 1.0 is not yet available.
+- Transformer Engine changed checkpoint metadata after v1.10, which can cause checkpoint incompatibilities. **Workaround:** use `model.dist_ckpt_load_strictness=log_all` when working with Transformer Engine v1.10 or higher. See [software component versions](https://docs.nvidia.com/nemo/megatron-bridge/latest/releases/software-versions.html) for TE versions per container.
+- For data preparation of GPT models, use your own dataset or an online dataset legally approved by your organization.
+- A race condition in the NeMo experiment manager can occur when multiple processes or threads attempt to access and modify shared resources simultaneously.
+- The Mistral and Mixtral tokenizers require a Hugging Face login.
+
+### Export and Deployment
+
+These notes apply to export and deployment behavior in older releases.
+
+- Exporting Gemma, Starcoder, and Falcon 7B models to TRT-LLM only works with a single GPU. If you attempt to export with multiple GPUs, no descriptive error message is shown.
+- Export Llama70B vLLM causes an out-of-memory issue.
+- Export vLLM does not support LoRA and P-tuning.
+- In-framework (PyTorch level) deployment with 8 GPUs is encountering an error.
+- Query script under `scripts/deploy/nlp/query.py` returns the error `'output_generation_logits'` in the 24.12 container.
+
+### Notebooks and Tutorials
+
+The following notebooks had functional issues at the time of the 24.12 release:
+
+- `ASR_with_NeMo.ipynb`
+- `ASR_with_Subword_Tokenization.ipynb`
+- `AudioTranslationSample.ipynb`
+- `Megatron_Synthetic_Tabular_Data_Generation.ipynb`
+- `SpellMapper_English_ASR_Customization.ipynb`
+- `FastPitch_ChineseTTS_Training.ipynb`
+- `NeVA Tutorial.ipynb`
+- `NeMo_Forced_Aligner_Tutorial.ipynb` — use the 24.09 container if this notebook is needed.
+
+### Multimodal
+
+These notes apply to multimodal tutorials and workflows in older releases.
+
+- LITA tutorial: the data preparation part in `tutorials/multimodal/LITA_Tutorial.ipynb` requires you to manually download the YouMakeup dataset instead of using the provided script.
+- Add `exp_manager.checkpoint_callback_params.save_nemo_on_train_end=True` to the NeVA notebook pretraining procedure to ensure an end-to-end workflow.
+
+### ASR
+
+These notes apply to ASR workflows in older releases.
+
+- Timestamp misalignment occurs in FastConformer ASR models when using the ASR decoder for diarization. Related issue: [NeMo#8438](https://github.com/NVIDIA/NeMo/issues/8438).
+
+## Report a New Issue
+
+Open an issue or discussion in the [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo) repository that owns the component — use [Libraries](/about/libraries) to find the right repo and docs site. For problems that span a container release, use [GitHub Discussions](https://github.com/orgs/NVIDIA-NeMo/discussions) and note your container tag (for example `nvcr.io/nvidia/nemo:26.02`).
diff --git a/fern/docs/pages/get-started/data.mdx b/fern/docs/pages/get-started/data.mdx
new file mode 100644
index 0000000..aeca868
--- /dev/null
+++ b/fern/docs/pages/get-started/data.mdx
@@ -0,0 +1,38 @@
+---
+title: Data
+subtitle: Get Started With Data Curation and Synthetic Data Libraries
+slug: get-started/data
+position: 10
+---
+
+import StageGuide from "@/components/StageGuide";
+
+Libraries for **Data** — curation, synthetic generation, PII handling, and SDG pipelines. Install and tutorial steps live on each library's docs site; this page lists every active repo in this stage.
+
+```mermaid
+flowchart LR
+ DATA["Data"] --> PRE["Pretraining"] --> RL["RL"] --> INF["Inference"]
+ E2E["E2E"] -.-> DATA & PRE & RL & INF
+
+ classDef active fill:#76B900,stroke:#3d5c00,stroke-width:3px,color:#fff
+ classDef dim fill:#f5f5f5,stroke:#ccc,color:#666
+
+ class PRE,RL,INF,E2E dim
+ class DATA active
+```
+
+
+
+## Typical Workflow
+
+Most data workflows move from raw inputs to curated, protected, or synthetic datasets that downstream training and RL libraries can consume.
+
+1. **Curate** raw corpora with [Curator](https://docs.nvidia.com/nemo/curator/latest/) (dedup, filtering, multimodal pipelines).
+2. **Generate** synthetic data with [Data Designer](https://nvidia-nemo.github.io/DataDesigner/latest/) or domain SDG tools.
+3. **Protect** sensitive fields with [Anonymizer](https://github.com/NVIDIA-NeMo/Anonymizer) before sharing or training.
+
+Hand off curated datasets to [Pretraining](/get-started/pretraining) or [RL](/get-started/rl) libraries.
+
+
+Pre-built container for large-scale curation jobs.
+
diff --git a/fern/docs/pages/get-started/e2e.mdx b/fern/docs/pages/get-started/e2e.mdx
new file mode 100644
index 0000000..500db4c
--- /dev/null
+++ b/fern/docs/pages/get-started/e2e.mdx
@@ -0,0 +1,46 @@
+---
+title: E2E
+subtitle: Get Started With Recipes, Pipelines, and Orchestration
+slug: get-started/e2e
+position: 14
+---
+
+import StageGuide from "@/components/StageGuide";
+
+Libraries for **E2E** — reference pipelines, Nemotron recipes, synthetic-data workflows, and experiment launchers that tie the stack together.
+
+```mermaid
+flowchart LR
+ DATA["Data"] --> PRE["Pretraining"] --> RL["RL"] --> INF["Inference"]
+ E2E["E2E"] -.-> DATA & PRE & RL & INF
+
+ classDef active fill:#76B900,stroke:#3d5c00,stroke-width:3px,color:#fff
+ classDef dim fill:#f5f5f5,stroke:#ccc,color:#666
+
+ class DATA,PRE,RL,INF dim
+ class E2E active
+```
+
+
+
+## Orchestration
+
+Use orchestration libraries when you need repeatable launches across local machines, SLURM, or Kubernetes.
+
+
+Configure, launch, and manage experiments on local machines, SLURM, and Kubernetes.
+
+
+## Reference Assets
+
+Use reference assets when you want complete recipes, cookbooks, datasets, or example pipelines instead of starting from a single library API.
+
+
+Pipelines for synthetic data generation and evaluation (math, code, science).
+
+
+
+Cookbooks, datasets, and reference examples for Nemotron models.
+
+
+Connect upstream stages: [Data](/get-started/data) → [Pretraining](/get-started/pretraining) → [RL](/get-started/rl) → [Inference](/get-started/inference).
diff --git a/fern/docs/pages/get-started/index.mdx b/fern/docs/pages/get-started/index.mdx
new file mode 100644
index 0000000..5010dd6
--- /dev/null
+++ b/fern/docs/pages/get-started/index.mdx
@@ -0,0 +1,91 @@
+---
+title: Get Started
+subtitle: Choose Your Path Into NeMo OSS
+slug: get-started
+position: 1
+---
+
+Pick how you want to begin. Start with [Task map](/get-started/task-map) if you know the work you want to do, or [Runtime chooser](/get-started/runtime-chooser) if you already know the library and need the right setup path.
+
+**NeMo Framework** paths cover the model lifecycle; **NeMo Platform** covers agents. Stages below match the [org README](https://github.com/NVIDIA-NeMo) and [Libraries](/about/libraries) catalog.
+
+
+
+
+Route tasks such as curation, fine-tuning, RL, evaluation, guardrails, and deployment to the right library.
+
+
+
+Choose Framework container, standalone image, pip/source install, or Platform setup.
+
+
+
+Quickstart and installation for model training and deployment.
+
+
+
+Agent evaluate, secure, tune, and deploy — CLI, SDK, and Studio.
+
+
+
+
+## Install and Quickstart
+
+Use these pages when you are ready to install a library or run a first example.
+
+
+
+
+Fastest paths by outcome: training, agents, data, RL, inference, speech, and experiments.
+
+
+
+pip, NGC containers, Platform setup, scale, and backend choice.
+
+
+
+
+## By Lifecycle Stage (Framework)
+
+Use stage pages when you know which part of the model lifecycle you are working in.
+
+
+
+
+Curation, synthetic data, PII handling, and SDG pipelines.
+
+
+
+Model training and fine-tuning — AutoModel, Megatron-Bridge, Speech.
+
+
+
+Post-training alignment, environments, and agent rollout.
+
+
+
+Evaluation, export, serving, guardrails, and NeMo Platform for agents.
+
+
+
+Reference pipelines, recipes, and experiment orchestration.
+
+
+
+
+## Decision Guide
+
+For a fuller routing table, use [Task map](/get-started/task-map).
+
+| I want to… | Scale | Start here |
+| --- | --- | --- |
+| Curate or synthesize data | Any | [Data](/get-started/data) |
+| Train or fine-tune | ≤1K GPUs | [Pretraining](/get-started/pretraining) → AutoModel |
+| Train at scale | 1K+ GPUs | [Pretraining](/get-started/pretraining) → Megatron-Bridge |
+| Align (DPO/GRPO) | Any | [RL](/get-started/rl) |
+| Evaluate or deploy a model | Any | [Inference](/get-started/inference) |
+| Ship or harden agents | Any | [Inference](/get-started/inference) → [NeMo Platform](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+| Run end-to-end recipes | Any | [E2E](/get-started/e2e) |
+| Speech AI | Any | [Pretraining](/get-started/pretraining) → NeMo Speech |
+
+Not sure which library owns your workload? Browse all repos on [Libraries](/about/libraries).
diff --git a/fern/docs/pages/get-started/inference.mdx b/fern/docs/pages/get-started/inference.mdx
new file mode 100644
index 0000000..efd7c77
--- /dev/null
+++ b/fern/docs/pages/get-started/inference.mdx
@@ -0,0 +1,46 @@
+---
+title: Inference
+subtitle: Get Started With Evaluation, Export, and Deployment
+slug: get-started/inference
+position: 13
+---
+
+import StageGuide from "@/components/StageGuide";
+
+Libraries for **Inference** in the **NeMo Framework** model lifecycle — benchmarking, export, serving, and guardrails. For **agents**, see [NeMo Platform](#shipping-agents) below or start at [Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/).
+
+```mermaid
+flowchart LR
+ DATA["Data"] --> PRE["Pretraining"] --> RL["RL"] --> INF["Inference"]
+ E2E["E2E"] -.-> DATA & PRE & RL & INF
+
+ classDef active fill:#76B900,stroke:#3d5c00,stroke-width:3px,color:#fff
+ classDef dim fill:#f5f5f5,stroke:#ccc,color:#666
+
+ class DATA,PRE,RL,E2E dim
+ class INF active
+```
+
+
+
+## Typical Workflow (Models)
+
+Most model inference workflows move from evaluation to export or deployment, with guardrails added where application behavior needs control.
+
+1. **Evaluate** with [Evaluator](https://docs.nvidia.com/nemo/evaluator/latest/) across benchmark suites and harnesses.
+2. **Export** to vLLM, TensorRT-LLM, or ONNX with [Export-Deploy](https://docs.nvidia.com/nemo/export-deploy/latest/).
+3. **Guard** production apps with [Guardrails](https://docs.nvidia.com/nemo/guardrails/latest/).
+
+Models usually come from [Pretraining](/get-started/pretraining) or [RL](/get-started/rl). For bundled Framework container versions, refer to [Container releases](/about/release-notes/containers).
+
+## Shipping Agents
+
+Agent workflows usually start with Platform when you want an integrated CLI, SDK, and Studio experience.
+
+If you are building **agents**, [NeMo Platform](https://github.com/NVIDIA-NeMo/nemo-platform) brings evaluation, guardrails, tuning, and deployment into one workflow with a CLI, SDK, and Studio UI. Use Evaluator or Guardrails directly when you want one library; start with Platform when you want those loops wired together.
+
+
+Setup, CLI, and docs — evaluate, secure, and optimize agents with NeMo libraries.
+
+
+For related guidance, refer to [Framework and Platform](/about/concepts/framework-and-platform) and [Ecosystem](/about/ecosystem#choose-framework-or-platform).
diff --git a/fern/docs/pages/get-started/installation.mdx b/fern/docs/pages/get-started/installation.mdx
new file mode 100644
index 0000000..6a215e2
--- /dev/null
+++ b/fern/docs/pages/get-started/installation.mdx
@@ -0,0 +1,98 @@
+---
+title: Installation
+subtitle: Pip, Containers, and Choosing a Backend
+slug: get-started/installation
+position: 3
+---
+
+How to install NeMo OSS libraries, choose Platform setup for agents, and pick a backend for your GPU scale. For a minimal first run, start with [Quickstart](/get-started/quickstart). For a setup decision before commands, use [Runtime chooser](/get-started/runtime-chooser).
+
+## Pip Install (Recommended for Development)
+
+Use package installs for local development, notebooks, and lightweight experiments when the library docs recommend them.
+
+| Workload | Install | Docs |
+| --- | --- | --- |
+| Hugging Face large language model (LLM) and vision language model (VLM) training | `pip install nemo-automodel` | [AutoModel installation](https://docs.nvidia.com/nemo/automodel/latest/guides/installation.html) |
+| Alignment (DPO, GRPO, SFT) | NeMo RL repo | [NeMo RL installation](https://docs.nvidia.com/nemo/rl/latest/about/installation.html) |
+| Speech ASR/TTS | `pip install nemo_toolkit[asr,tts]` | [NeMo Speech installation](https://docs.nvidia.com/nemo/speech/nightly/starthere/install.html) |
+| Data curation | Curator repo | [Curator installation](https://docs.nvidia.com/nemo/curator/get-started/installation) |
+| Integrated agent workflows | NeMo Platform repo | [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+
+Each library publishes install extras and version pins in its own documentation. Use [Libraries](/about/libraries) to find the repo and docs site for your stage.
+
+## NGC Containers (Recommended for Production Stacks)
+
+Pre-built images bundle tested dependency sets. Use the [container catalog](/about/release-notes/containers) for current tags and pull commands.
+
+The **NeMo Framework** image (`nvcr.io/nvidia/nemo`) is the multi-library training stack. Standalone images exist for AutoModel, RL, and Curator.
+
+| Runtime path | Typical fit |
+| --- | --- |
+| **Framework container** | Cross-library Framework workflows and tested component sets. |
+| **Standalone container** | Focused library workflows with dedicated images. |
+| **pip or source install** | Local development, notebooks, and contribution workflows. |
+| **Platform setup** | Integrated agent workflows with CLI, SDK, and Studio. |
+
+See [Runtime chooser](/get-started/runtime-chooser) for setup guidance.
+
+## NeMo Platform Setup
+
+Use NeMo Platform when you want an integrated agent workflow with CLI, SDK, and Studio rather than one standalone library.
+
+
+
+
+Follow the current setup path for agent evaluation, guardrails, tuning, and deployment.
+
+
+
+Browse source, examples, issues, and release notes for the Platform entry point.
+
+
+
+
+## Scale and Backends
+
+Use scale and checkpoint needs to choose between the Hugging Face-native path and the Megatron-Core path.
+
+| GPUs | Libraries | Checkpoint conversion | Notes |
+| --- | --- | --- | --- |
+| 1–1,000 | [AutoModel](https://github.com/NVIDIA-NeMo/Automodel), [NeMo RL](https://github.com/NVIDIA-NeMo/RL) | Not required for HF-native training | PyTorch / Hugging Face path |
+| 1,000+ | [Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge), [NeMo RL](https://github.com/NVIDIA-NeMo/RL) | [HF ↔ Megatron](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/examples/conversion/README.md) | Megatron-Core at scale |
+
+Stage-specific libraries and entry points:
+
+
+
+
+Curator, Data Designer, anonymization, SDG.
+
+
+
+AutoModel, Megatron-Bridge, Speech, optimizers.
+
+
+
+NeMo RL, Gym, agent server.
+
+
+
+Evaluator, Export-Deploy, Guardrails.
+
+
+
+Skills, Nemotron recipes, NeMo Run.
+
+
+
+
+## Experiment Tracking
+
+Use NeMo Run when setup choices need to carry into repeatable experiment launch and tracking.
+
+
+Launch and track experiments on local machines, SLURM, and Kubernetes.
+
+
+Also listed under [E2E](/get-started/e2e).
diff --git a/fern/docs/pages/get-started/pretraining.mdx b/fern/docs/pages/get-started/pretraining.mdx
new file mode 100644
index 0000000..ab8e291
--- /dev/null
+++ b/fern/docs/pages/get-started/pretraining.mdx
@@ -0,0 +1,40 @@
+---
+title: Pretraining
+subtitle: Get Started With Model Training and Fine-Tuning
+slug: get-started/pretraining
+position: 11
+---
+
+import StageGuide from "@/components/StageGuide";
+
+Libraries for **Pretraining** — from Hugging Face fine-tuning on a single node to thousand-GPU Megatron pretraining and Speech AI. Use AutoModel for large language models (LLMs) and vision language models (VLMs) at modest scale; use Megatron-Bridge for cluster-scale jobs.
+
+```mermaid
+flowchart LR
+ DATA["Data"] --> PRE["Pretraining"] --> RL["RL"] --> INF["Inference"]
+ E2E["E2E"] -.-> DATA & PRE & RL & INF
+
+ classDef active fill:#76B900,stroke:#3d5c00,stroke-width:3px,color:#fff
+ classDef dim fill:#f5f5f5,stroke:#ccc,color:#666
+
+ class DATA,RL,INF,E2E dim
+ class PRE active
+```
+
+
+
+## Choose a Path
+
+Choose the pretraining path based on model format, target scale, and whether your workflow is Hugging Face-native or Megatron-based.
+
+| Goal | GPUs | Library |
+| --- | --- | --- |
+| Fine-tune Hugging Face LLMs and VLMs | 1–1,000 | [AutoModel](https://docs.nvidia.com/nemo/automodel/latest/) |
+| Large-scale pretrain / SFT | 1,000+ | [Megatron-Bridge](https://docs.nvidia.com/nemo/megatron-bridge/latest/) |
+| Speech ASR, TTS, speech-LM | Any | [NeMo Speech](https://docs.nvidia.com/nemo/speech/nightly/) |
+
+Fastest first run: [Quickstart](/get-started/quickstart). Install details: [Installation](/get-started/installation).
+
+Model recipes, example configs, and supported architectures live on each library's docs site — for example [AutoModel examples](https://github.com/NVIDIA-NeMo/Automodel/tree/main/examples) and [Megatron-Bridge recipes](https://docs.nvidia.com/nemo/megatron-bridge/latest/).
+
+Post-training alignment: [RL](/get-started/rl).
diff --git a/fern/docs/pages/get-started/quickstart.mdx b/fern/docs/pages/get-started/quickstart.mdx
new file mode 100644
index 0000000..c8d4654
--- /dev/null
+++ b/fern/docs/pages/get-started/quickstart.mdx
@@ -0,0 +1,71 @@
+---
+title: Quickstart
+subtitle: Fast Paths to Your First Result on NVIDIA GPUs
+slug: get-started/quickstart
+position: 2
+---
+
+Choose the shortest path to a first useful result. For install options and containers, refer to [Installation](/get-started/installation).
+
+## Choose a First Result
+
+Use this table to start from the outcome you want, then follow the linked docs for current commands and examples.
+
+| First Result | Start Here | Good Fit |
+| --- | --- | --- |
+| Fine-tune an LLM or VLM | [AutoModel quick start](https://docs.nvidia.com/nemo/automodel/latest/launcher/local-workstation.html#quick-start-choose-your-job-launch-option) | Hugging Face models on local workstations or clusters. |
+| Build or ship an agent workflow | [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) | Agent evaluation, guardrails, tuning, and deployment with CLI, SDK, and Studio. |
+| Curate or prepare training data | [Curator getting started](https://docs.nvidia.com/nemo/curator/get-started/) | Text, image, video, or audio data pipelines. |
+| Run post-training or RL | [NeMo RL quick start](https://docs.nvidia.com/nemo/rl/latest/about/quick-start.html) | SFT, DPO, GRPO, RL, and distillation workflows. |
+| Evaluate a model | [NeMo Evaluator Launcher quickstart](https://docs.nvidia.com/nemo/evaluator/latest/get-started/quickstart/launcher.html) | Fast benchmark runs with the Evaluator launcher. |
+| Export or deploy a model | [Export-Deploy install and overview](https://docs.nvidia.com/nemo/export-deploy/latest/index.html) | Export paths, serving backends, and deployment setup. |
+| Work on speech AI | [NeMo Speech five-minute inference](https://docs.nvidia.com/nemo/speech/nightly/starthere/ten_minutes.html) | ASR, TTS, speech language models, and speech tutorials. |
+| Launch repeatable experiments | [NeMo Run quickstart](https://docs.nvidia.com/nemo/run/nightly/guides/quickstart.html) | Local, SLURM, and Kubernetes experiment orchestration. |
+
+## Follow a Stage Path
+
+Use the stage pages when your first result spans multiple repositories or you need more context before choosing a library.
+
+
+
+
+Curator, Data Designer, anonymization, and synthetic data generation.
+
+
+
+AutoModel, Megatron-Bridge, NeMo Speech, optimizers, and scale choices.
+
+
+
+NeMo RL, Gym, agent environments, and rollout infrastructure.
+
+
+
+Evaluator, Export-Deploy, Guardrails, and NeMo Platform for agents.
+
+
+
+NeMo Run, Skills, Nemotron recipes, and reference workflows.
+
+
+
+
+## Next Steps
+
+Use these links when you are ready to move from a first run to setup, routing, or stage-specific docs.
+
+
+
+
+pip and NGC containers, GPU scale, and backend choice.
+
+
+
+Search all 22 repos by stage or tag.
+
+
+
+Pull tested NGC images for Framework, AutoModel, RL, and Curator.
+
+
+
diff --git a/fern/docs/pages/get-started/rl.mdx b/fern/docs/pages/get-started/rl.mdx
new file mode 100644
index 0000000..46b46bc
--- /dev/null
+++ b/fern/docs/pages/get-started/rl.mdx
@@ -0,0 +1,39 @@
+---
+title: RL
+subtitle: Get Started With Alignment and Reinforcement Learning
+slug: get-started/rl
+position: 12
+---
+
+import StageGuide from "@/components/StageGuide";
+
+Libraries for **RL** — SFT, DPO, GRPO, on-policy distillation, RL environments, and agent rollout infrastructure.
+
+```mermaid
+flowchart LR
+ DATA["Data"] --> PRE["Pretraining"] --> RL["RL"] --> INF["Inference"]
+ E2E["E2E"] -.-> DATA & PRE & RL & INF
+
+ classDef active fill:#76B900,stroke:#3d5c00,stroke-width:3px,color:#fff
+ classDef dim fill:#f5f5f5,stroke:#ccc,color:#666
+
+ class DATA,PRE,INF,E2E dim
+ class RL active
+```
+
+
+
+## Common Entry Points
+
+Use these entry points to choose between post-training algorithms, RL environments, and agent rollout infrastructure.
+
+| Technique | Start in docs | Library |
+| --- | --- | --- |
+| GRPO, DPO, SFT | [NeMo RL examples](https://docs.nvidia.com/nemo/rl/latest/) | NeMo RL |
+| RL environments | [NeMo Gym](https://docs.nvidia.com/nemo/gym/main/about/) | Gym |
+
+Train base models first through [Pretraining](/get-started/pretraining), then align here. Evaluate with [Inference](/get-started/inference) libraries.
+
+
+Pre-built alignment and RL container.
+
diff --git a/fern/docs/pages/get-started/runtime-chooser.mdx b/fern/docs/pages/get-started/runtime-chooser.mdx
new file mode 100644
index 0000000..17b385d
--- /dev/null
+++ b/fern/docs/pages/get-started/runtime-chooser.mdx
@@ -0,0 +1,78 @@
+---
+title: Runtime Chooser
+subtitle: Pick the Setup Path Before Running Examples
+slug: get-started/runtime-chooser
+position: 4
+---
+
+Choose a runtime after you know the library or task. Use this page to choose the setup family, then follow the linked library docs for commands.
+
+| Runtime path | Best for | Check first |
+| --- | --- | --- |
+| **Framework container** (`nvcr.io/nvidia/nemo:`) | Cross-library Framework workflows, Megatron-Bridge, Evaluator, Export-Deploy, Run, and Speech workflows packaged together | [Container releases](/about/release-notes/containers) |
+| **Standalone container** | Focused workflows for libraries with dedicated images, such as AutoModel, RL, or Curator | [Container catalog](/about/release-notes/containers) and the library docs |
+| **pip or package install** | Local development, notebooks, small experiments, and integrations with existing Python environments | The linked library install page |
+| **Source checkout** | Contributing, debugging, running repo-local examples, or using unreleased code | The GitHub repo and `CONTRIBUTING.md` |
+| **Platform setup** | Integrated agent workflows with CLI, SDK, and Studio | [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+
+## Runtime Flow
+
+Start with the task you want to run. If you already know the library, start there instead. The next question is whether the workflow is cross-library, single-library, source-based, or an integrated Platform workflow.
+
+```mermaid
+flowchart TB
+ Start["Task you want to run"]
+ Known["Library"]
+ Agent["Integrated agent workflow?"]
+ Cross["Cross-library Framework workflow?"]
+ Source["Need repo files or unreleased code?"]
+ Dedicated["Dedicated library container available?"]
+ Platform["Platform setup"]
+ Framework["Framework container"]
+ Checkout["Source checkout"]
+ Standalone["Standalone container"]
+ Package["pip or package install"]
+
+ Start --> Known
+ Known --> Agent
+ Agent -->|Yes| Platform
+ Agent -->|No| Cross
+ Cross -->|Yes| Framework
+ Cross -->|No| Source
+ Source -->|Yes| Checkout
+ Source -->|No| Dedicated
+ Dedicated -->|Yes| Standalone
+ Dedicated -->|No| Package
+```
+
+## Practical Checks
+
+Run through these checks before following commands from a guide or example.
+
+| Before you run | Why it matters |
+| --- | --- |
+| Check the linked library docs | Install extras, optional dependencies, and support matrices can vary by library and release. |
+| Check container release notes | Framework container component versions and cross-component known issues are listed by release. |
+| Check whether the example needs repo files | Some examples assume a source checkout, even when the package can be installed from pip. |
+| Check checkpoint format | AutoModel, Megatron-Bridge, RL, Evaluator, and Export-Deploy workflows can depend on Hugging Face, Megatron, or serving-specific formats. |
+| Check data and model credentials | Hugging Face tokens, NGC access, S3 credentials, and cluster credentials are often required outside the Python package install. |
+
+## Related Concepts
+
+Use these pages when you need deeper context on installs, task routing, or setup commands.
+
+
+
+
+Understand how runtime paths fit into the NeMo OSS model.
+
+
+
+Start from the work you want to do.
+
+
+
+See the main install families and backend scale guidance.
+
+
+
diff --git a/fern/docs/pages/get-started/task-map.mdx b/fern/docs/pages/get-started/task-map.mdx
new file mode 100644
index 0000000..0baf041
--- /dev/null
+++ b/fern/docs/pages/get-started/task-map.mdx
@@ -0,0 +1,51 @@
+---
+title: Task Map
+subtitle: Start From the Work You Want to Do
+slug: get-started/task-map
+position: 1
+---
+
+Use this map when you know the task but not the repo name. Each row points to a starting library, a runtime path to check first, and the docs with detailed commands.
+
+| I want to... | Stage | Start with | Runtime path | Next docs |
+| --- | --- | --- | --- | --- |
+| Curate text, image, video, or audio data | Data | Curator | Curator install or Curator container | [Curator docs](https://docs.nvidia.com/nemo/curator/latest/) |
+| Generate synthetic data | Data / E2E | Data Designer or Skills | Library install | [Data Designer docs](https://nvidia-nemo.github.io/DataDesigner/latest/), [Skills docs](https://nvidia-nemo.github.io/Skills/) |
+| Protect or anonymize sensitive data | Data | Anonymizer or Safe-Synthesizer | Library docs | [Libraries](/about/libraries) |
+| Fine-tune a Hugging Face LLM or VLM | Pretraining | AutoModel | AutoModel container or pip | [AutoModel docs](https://docs.nvidia.com/nemo/automodel/latest/) |
+| Train at Megatron scale | Pretraining | Megatron-Bridge | Framework container | [Megatron-Bridge docs](https://docs.nvidia.com/nemo/megatron-bridge/latest/) |
+| Convert Hugging Face and Megatron checkpoints | Pretraining | Megatron-Bridge | Framework container | [Megatron-Bridge conversion docs](https://docs.nvidia.com/nemo/megatron-bridge/latest/) |
+| Build speech AI workflows | Pretraining | NeMo Speech | NeMo Speech install | [NeMo Speech docs](https://docs.nvidia.com/nemo/speech/nightly/) |
+| Run SFT, DPO, GRPO, distillation, or RL | RL | NeMo RL | NeMo RL container or source checkout | [NeMo RL docs](https://docs.nvidia.com/nemo/rl/latest/) |
+| Build RL environments for models or agents | RL | Gym | Gym install | [Gym docs](https://docs.nvidia.com/nemo/gym/main/about/) |
+| Run multi-turn agent rollouts | RL | ProRL Agent Server | Source checkout | [ProRL Agent Server](https://github.com/NVIDIA-NeMo/ProRL-Agent-Server#readme) |
+| Evaluate a model or agent | Inference | Evaluator | Framework container or library install | [Evaluator docs](https://docs.nvidia.com/nemo/evaluator/latest/) |
+| Export or serve a model | Inference | Export-Deploy | Framework container | [Export-Deploy docs](https://docs.nvidia.com/nemo/export-deploy/latest/) |
+| Add guardrails to an app or agent | Inference | Guardrails | Guardrails install | [Guardrails docs](https://docs.nvidia.com/nemo/guardrails/latest/) |
+| Build integrated agent workflows | Inference | NeMo Platform | Platform setup | [NeMo Platform setup](https://nvidia-nemo.github.io/nemo-platform/main/get-started/setup/) |
+| Launch experiments on local, SLURM, or Kubernetes | E2E | NeMo Run | Framework container or library install | [NeMo Run docs](https://docs.nvidia.com/nemo/run/latest/) |
+| Follow reference recipes and cookbooks | E2E | Skills or Nemotron | Repo README and recipe docs | [Skills docs](https://nvidia-nemo.github.io/Skills/), [Nemotron](https://github.com/NVIDIA-NeMo/Nemotron#readme) |
+
+## Choosing the Runtime
+
+After you pick a library, check [Runtime chooser](/get-started/runtime-chooser). Runtime choice is often the difference between a quick local experiment, a containerized Framework workflow, and a source checkout.
+
+## If the Row Is Close but Not Exact
+
+Use [Libraries](/about/libraries) to search by stage, kind, and tag. Use [Where to Find Information](/about/concepts/documentation-surfaces) for setup, releases, examples, terminology, and support links.
+
+
+
+
+Pick Framework container, standalone container, pip/source install, or Platform setup.
+
+
+
+Search all catalog repos by stage, kind, and tag.
+
+
+
+Find third-party writeups and videos for additional perspective.
+
+
+
diff --git a/fern/docs/pages/index.mdx b/fern/docs/pages/index.mdx
new file mode 100644
index 0000000..20b684a
--- /dev/null
+++ b/fern/docs/pages/index.mdx
@@ -0,0 +1,88 @@
+---
+title: NeMo OSS
+subtitle: Open Source Libraries From the NVIDIA-NeMo GitHub Organization
+slug: ""
+---
+
+**NeMo OSS** brings NVIDIA's open source NeMo work together in one staged hub: GitHub repositories, library documentation, NGC containers, and orientation pages for choosing the right workflow. Use these pages to find the right library, stack, or container:
+
+- **NeMo Framework** — build and run the model lifecycle: data, training, alignment, evaluation, and deployment.
+- **NeMo Platform** — integrate agent workflows: evaluate, secure, tune, and deploy agents.
+
+These open source projects are part of the broader [NVIDIA NeMo](https://www.nvidia.com/en-us/ai-data-science/products/nemo/) software suite.
+
+## Start From Your Task
+
+Use these entry points when you know the job you want to do and need the right repo, runtime, or catalog view.
+
+
+
+
+Find the right repo from the work you want to do: curate data, train, align, evaluate, deploy, or build agents.
+
+
+
+Pick Framework container, standalone container, pip/source install, or Platform setup.
+
+
+
+Browse all 22 repos — search by stage, kind, or tag.
+
+
+
+
+## Choose Your Stack
+
+Use these cards when you already know whether you are building model workflows or agent workflows.
+
+
+
+
+Train and deploy models — quickstart, install, and guides by lifecycle stage.
+
+
+
+Ship agents — CLI, SDK, and Studio UI over NeMo libraries.
+
+
+
+
+## Understand NeMo OSS
+
+Use these pages when you need the mental model, ecosystem position, or architecture before choosing a library.
+
+
+
+
+How Framework, Platform, libraries, and containers fit together.
+
+
+
+How NeMo OSS fits in NVIDIA NeMo and which path to choose.
+
+
+
+Three layers, pipeline diagram, backends, and NGC containers.
+
+
+
+
+## Releases and Community
+
+Use these pages to check releases, known issues, and community entry points.
+
+
+
+
+Framework NGC tags, pull commands, and component versions.
+
+
+
+Cross-component Framework container issues by tag.
+
+
+
+Discussions, announcements, and how to contribute.
+
+
+
diff --git a/fern/docs/pages/resources/community.mdx b/fern/docs/pages/resources/community.mdx
new file mode 100644
index 0000000..d879c41
--- /dev/null
+++ b/fern/docs/pages/resources/community.mdx
@@ -0,0 +1,75 @@
+---
+title: Community
+subtitle: Discuss, Contribute, and Stay Up to Date
+slug: resources/community
+---
+
+## Get Involved
+
+Use these links to find discussions, repositories, releases, and contribution paths.
+
+
+
+
+Questions, ideas, and announcements across the org.
+
+
+
+Browse and star projects in the NVIDIA-NeMo organization.
+
+
+
+Latest NGC container tags, component versions, and known issues.
+
+
+
+Cross-component container issues by release tag.
+
+
+
+Container releases and known issues for NeMo Framework.
+
+
+
+
+Each repository includes its own `CONTRIBUTING.md` and issue templates. Open issues or discussions in the repo that owns the component you are using.
+
+## NeMo Assist
+
+Use NeMo Assist when you want a guided answer across documentation and code.
+
+
+Chat with NeMo documentation and code — try NeMo Assist for guided answers across the open source libraries.
+
+
+## Recent Highlights
+
+Use these links to catch up on recent discussions and announcements from selected libraries.
+
+### AutoModel
+
+These AutoModel highlights point to recent training and Hugging Face workflow discussions.
+
+- [Enabling PyTorch native pipeline parallelism for HF models](https://github.com/NVIDIA-NeMo/Automodel/discussions/589)
+- [Day-0 Hugging Face support](https://github.com/NVIDIA-NeMo/Automodel/discussions/477)
+- [Gemma 3n multimodal fine-tuning](https://github.com/NVIDIA-NeMo/Automodel/discussions/494)
+
+### NeMo RL
+
+These NeMo RL highlights point to recent post-training and optimization discussions.
+
+- [On-policy distillation](https://github.com/NVIDIA-NeMo/RL/discussions/1445)
+- [FP8 quantization](https://github.com/NVIDIA-NeMo/RL/discussions/1216)
+- [10× MoE weight transfer](https://github.com/NVIDIA-NeMo/RL/discussions/1189)
+
+### NeMo Speech
+
+These NeMo Speech highlights point to recent speech fine-tuning discussions.
+
+- [Fine-tune NeMo models with Granary data](https://github.com/NVIDIA-NeMo/NeMo/discussions/14758)
+
+## License
+
+This section summarizes the top-level license expectation for the OSS repos.
+
+Apache 2.0. Third-party attributions are documented in each repository.
diff --git a/fern/docs/pages/resources/external-learning.mdx b/fern/docs/pages/resources/external-learning.mdx
new file mode 100644
index 0000000..dd34a9c
--- /dev/null
+++ b/fern/docs/pages/resources/external-learning.mdx
@@ -0,0 +1,95 @@
+---
+title: External Learning
+subtitle: Community Writeups, Videos, and Partner Examples
+slug: resources/external-learning
+---
+
+These third-party resources can help you see how developers approach NeMo OSS in the wild. Treat commands and version pins as examples, and verify current setup steps in the linked library docs.
+
+## Guardrails
+
+These resources show how external authors frame Guardrails for safety, RAG, and application control.
+
+
+
+
+Practical walkthrough of safety rails, deterministic dialogue, RAG, and tool use.
+
+
+
+Cloud integration example for adding Guardrails around LLM applications.
+
+
+
+Short video listing for a hands-on Guardrails demo.
+
+
+
+
+Common themes: Colang, rail types, LangChain/RAG integration, provider setup, latency and cost, and how Guardrails compares with model-based classifiers such as Llama Guard.
+
+## Data Curation
+
+These resources show how external authors approach Curator pipelines, modality setup, and training-data preparation.
+
+
+
+
+Walkthrough of a practical text curation flow with NeMo Curator.
+
+
+
+Task-oriented view of web-data curation, deduplication, and training-ready shards.
+
+
+
+Generated map of Curator tutorial structure and source-linked examples.
+
+
+
+
+Common themes: modality-specific setup, Ray execution, GPU and FFmpeg prerequisites, cluster scale, and the move from raw data to training-ready outputs.
+
+## Training, RL, and Checkpoints
+
+These resources show how external authors approach post-training, backend choice, rollout infrastructure, and checkpoint flow.
+
+
+
+
+Beginner-oriented framing of SFT, DPO, GRPO, and RL for LLMs.
+
+
+
+Cloud launch example for NeMo RL training jobs.
+
+
+
+Large-scale example using Megatron-Bridge and verl for LoRA RL.
+
+
+
+Example of using NeMo Gym environments with TRL.
+
+
+
+
+Common themes: backend choice, rollout and training separation, Hugging Face tokens, checkpoint formats, and multi-node orchestration.
+
+## Hugging Face Ecosystem
+
+These resources show how AutoModel appears in Hugging Face-native workflows.
+
+
+
+
+Shows AutoModel as a Hugging Face-compatible training path for LLMs and VLMs.
+
+
+
+Shows AutoModel for diffusion fine-tuning with Diffusers-format models.
+
+
+
+
+Common themes: Hugging Face-native workflows, no checkpoint conversion for AutoModel paths, model coverage, data preprocessing, and distributed launch configuration.
diff --git a/fern/docs/pages/resources/glossary.mdx b/fern/docs/pages/resources/glossary.mdx
new file mode 100644
index 0000000..d12fa6c
--- /dev/null
+++ b/fern/docs/pages/resources/glossary.mdx
@@ -0,0 +1,203 @@
+---
+title: Glossary
+subtitle: Terms Used Across NeMo OSS Documentation
+slug: resources/glossary
+---
+
+Use this glossary for quick lookup of NeMo OSS terminology. For relationship-level explanations, use [Concepts](/about/concepts).
+
+## A
+
+Terms in this section begin with A.
+
+AutoModel
+: PyTorch distributed training library for LLMs and VLMs with Hugging Face-native workflows. Use it when you want a PyTorch / Hugging Face training path.
+
+## C
+
+Terms in this section begin with C.
+
+Catalog
+: The searchable library inventory on [Libraries](/about/libraries), organized by stage, kind, and tags.
+
+Checkpoint conversion
+: The process of moving model weights between formats, such as Hugging Face and Megatron. Megatron-Bridge provides the primary Hugging Face to Megatron conversion path.
+
+Colang
+: The modeling language used by NeMo Guardrails to define conversational flows, rails, and actions.
+
+Container
+: An NGC image that packages a tested runtime. NeMo OSS uses both the multi-library Framework container and standalone containers for selected libraries.
+
+## D
+
+Terms in this section begin with D.
+
+Data
+: The lifecycle stage for curating, filtering, synthesizing, anonymizing, or governing datasets before training or evaluation.
+
+Dask
+: A distributed Python computing framework. Older Curator workflows used Dask; current Curator docs describe the Ray-based pipeline architecture.
+
+## E
+
+Terms in this section begin with E.
+
+E2E
+: End-to-end. The lifecycle stage for recipes, orchestration, experiment launch, and reference assets that span multiple stages.
+
+Evaluator
+: Library for scalable, reproducible model and agent evaluation across benchmarks and harnesses.
+
+Export-Deploy
+: Library for exporting and deploying NeMo and Hugging Face models to serving stacks such as TensorRT-LLM, vLLM, and ONNX-based paths.
+
+## F
+
+Terms in this section begin with F.
+
+Framework container
+: The multi-library NGC image `nvcr.io/nvidia/nemo:`. It packages selected Framework components for tested workflows.
+
+Framework libraries
+: Libraries that participate in the NeMo Framework model lifecycle from data through deployment.
+
+## G
+
+Terms in this section begin with G.
+
+GRPO
+: Group Relative Policy Optimization, a reinforcement learning method used in post-training workflows.
+
+Guardrails
+: Library for programmable guardrails for LLM-based conversational systems.
+
+Gym
+: Library for RL environments and benchmarks used to evaluate and improve models and agents.
+
+## H
+
+Terms in this section begin with H.
+
+Hugging Face format
+: Model artifacts that follow Hugging Face `transformers` or related ecosystem conventions, such as configs, tokenizers, and safetensors weights. AutoModel uses Hugging Face-native paths; Megatron-Bridge converts between Hugging Face and Megatron formats.
+
+## I
+
+Terms in this section begin with I.
+
+Inference
+: The lifecycle stage for evaluation, export, serving, deployment, and guardrails.
+
+Integration
+: A repo kind for products that compose several libraries behind one product surface. NeMo Platform is the primary example.
+
+## K
+
+Terms in this section begin with K.
+
+Kind
+: The role a repo plays in the catalog: library, integration, reference, or infrastructure.
+
+## L
+
+Terms in this section begin with L.
+
+Library
+: A focused open source repo with its own source, docs, releases, install paths, and issue tracker.
+
+Lifecycle stage
+: The primary workflow stage assigned to a repo: Data, Pretraining, RL, Inference, or E2E.
+
+## M
+
+Terms in this section begin with M.
+
+Megatron-Bridge
+: Megatron-Core training library with bidirectional Hugging Face checkpoint conversion.
+
+Megatron format
+: Model artifacts organized for Megatron-Core training and parallelism. Use Megatron-Bridge when a workflow needs to move between Hugging Face and Megatron formats.
+
+## N
+
+Terms in this section begin with N.
+
+NeMo Framework
+: The model-lifecycle stack for data, training, RL, evaluation, export, and deployment. In container contexts, the name can also refer to the `nvcr.io/nvidia/nemo` Framework container.
+
+NeMo OSS
+: The public open source side of NVIDIA NeMo: the [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo) GitHub organization, documentation, and related OSS containers.
+
+NeMo Platform
+: Agent integration product with CLI, SDK, and Studio for evaluating, securing, tuning, and deploying agents using selected NeMo libraries.
+
+NeMo Speech
+: Speech AI documentation and source in the [NVIDIA-NeMo/NeMo](https://github.com/NVIDIA-NeMo/NeMo) repo.
+
+NGC
+: NVIDIA GPU Cloud, the catalog where NVIDIA publishes container images and model assets.
+
+## P
+
+Terms in this section begin with P.
+
+Pretraining
+: The lifecycle stage for training, fine-tuning, adapting models, and converting training formats.
+
+## R
+
+Terms in this section begin with R.
+
+RAG
+: Retrieval-augmented generation. A pattern where an application retrieves relevant context before generating an answer.
+
+Rail
+: A programmable Guardrails behavior that can guide, block, transform, retrieve, or execute logic around an LLM interaction.
+
+Ray
+: A distributed execution framework used by current Curator and RL workflows for scaling Python workloads.
+
+Reference
+: A repo kind for recipes, cookbooks, datasets, and example pipelines. Skills and Nemotron are examples.
+
+Repo
+: A GitHub repository in the [NVIDIA-NeMo](https://github.com/NVIDIA-NeMo) organization.
+
+Reward model
+: A model or scoring function used to evaluate candidate outputs during alignment or reinforcement learning workflows.
+
+RL
+: Reinforcement learning. In NeMo OSS, the RL stage includes post-training workflows such as SFT, DPO, GRPO, distillation, and agent improvement.
+
+Rollout
+: Model-generated trajectories or interactions used by RL training workflows, especially for agent or environment-based training.
+
+Runtime path
+: The setup family used to run a workflow: Framework container, standalone container, pip/source install, source checkout, or Platform setup.
+
+## S
+
+Terms in this section begin with S.
+
+Stage
+: The primary lifecycle bucket used by the library catalog.
+
+Standalone container
+: A library-specific NGC image, such as AutoModel, RL, or Curator, used for workflows that fit a focused runtime.
+
+## T
+
+Terms in this section begin with T.
+
+Tags
+: Catalog search facets for modality, technique, or role, such as `speech`, `agents`, `evaluation`, or `deployment`.
+
+## Related Documentation
+
+Use these pages when a term needs more context than a glossary definition.
+
+- [Concepts](/about/concepts)
+- [Ecosystem](/about/ecosystem)
+- [Architecture](/about/architecture)
+- [Libraries](/about/libraries)
diff --git a/fern/docs/pages/resources/index.mdx b/fern/docs/pages/resources/index.mdx
new file mode 100644
index 0000000..383a851
--- /dev/null
+++ b/fern/docs/pages/resources/index.mdx
@@ -0,0 +1,31 @@
+---
+title: Resources
+subtitle: Reference Links, Community Paths, and Terminology
+slug: resources
+---
+
+Use Resources when you need lookup material or a next step outside the conceptual flow.
+
+
+
+
+Lookup definitions for NeMo OSS terms, acronyms, and product names.
+
+
+
+Third-party blogs, videos, partner examples, and recurring themes.
+
+
+
+GitHub discussions, repositories, release links, and contribution entry points.
+
+
+
+Search the catalog of NVIDIA-NeMo repositories.
+
+
+
+Framework container releases, component versions, and known issues.
+
+
+
diff --git a/fern/fern.config.json b/fern/fern.config.json
new file mode 100644
index 0000000..aacfddd
--- /dev/null
+++ b/fern/fern.config.json
@@ -0,0 +1,4 @@
+{
+ "organization": "nvidia",
+ "version": "5.29.0"
+}
diff --git a/fern/tsconfig.json b/fern/tsconfig.json
new file mode 100644
index 0000000..9576342
--- /dev/null
+++ b/fern/tsconfig.json
@@ -0,0 +1,14 @@
+{
+ "compilerOptions": {
+ "target": "ES2020",
+ "lib": ["ES2020", "DOM", "DOM.Iterable"],
+ "jsx": "react-jsx",
+ "module": "ESNext",
+ "moduleResolution": "bundler",
+ "strict": true,
+ "skipLibCheck": true,
+ "noEmit": true,
+ "isolatedModules": true
+ },
+ "include": ["components/**/*.ts", "components/**/*.tsx"]
+}
diff --git a/nemo-fw-presentation-outline.md b/nemo-fw-presentation-outline.md
new file mode 100644
index 0000000..9c6454e
--- /dev/null
+++ b/nemo-fw-presentation-outline.md
@@ -0,0 +1,364 @@
+# NeMo Framework: Technical Writer Presentation Outline
+
+> **Audience:** Technical writing team
+> **Goal:** Introduce what NeMo Framework is, walk through each repo, and highlight what writers need to know
+> **Estimated time:** 45–60 min
+> **Diagrams:** See the `assets/` folder for per-product architecture diagrams
+
+---
+
+## 1. What Is NeMo Framework?
+
+- **One-liner:** An open-source collection of NVIDIA libraries that covers every stage of the generative AI model lifecycle — from data curation, to training, alignment, evaluation, and deployment.
+- Supports LLMs, VLMs, Speech, and Diffusion models.
+- Scales from a single GPU on a workstation to 10,000+ GPU nodes on SLURM/Kubernetes clusters.
+- Day-0 Hugging Face support: users can train virtually any model on the HF Hub without format conversion.
+- All repos live under the **[NVIDIA-NeMo](https://github.com/NVIDIA-NeMo)** GitHub org. Apache 2.0 licensed.
+
+### Key Talking Points
+
+- NeMo Framework is **not** a single repo — it is an **ecosystem of ~15 focused repositories**.
+- Each repo has its own docs site, container, and release cadence.
+- Optimized NGC containers are published for the core repos (AutoModel, Megatron-Bridge, RL, Curator, Evaluator, Export-Deploy).
+
+---
+
+## 2. The Pipeline at a Glance
+
+
+
+```
+Data ──▶ Training ──▶ Alignment ──▶ Evaluation ──▶ Deployment
+```
+
+| Stage | Primary Repos |
+|-------|---------------|
+| **Data** | Curator, Data Designer, Skills |
+| **Training** | AutoModel, Megatron-Bridge, NeMo Speech, DFM, Emerging-Optimizers |
+| **Alignment** | NeMo RL, NeMo Gym |
+| **Evaluation** | Evaluator, Skills |
+| **Deployment** | Export-Deploy, Guardrails |
+| **Infrastructure** | NeMo Run |
+| **Models/Recipes** | Nemotron |
+
+---
+
+## 3. Data Stage
+
+### 3a. NeMo Curator
+
+
+
+- **Repo:** [NVIDIA-NeMo/Curator](https://github.com/NVIDIA-NeMo/Curator) — 1,394 stars
+- **What it does:** GPU-accelerated data curation at scale for training better AI models.
+- **Modalities:** Text, Image, Video, Audio.
+- **Highlights for writers:**
+ - **Text:** 30+ heuristic filters, fuzzy/exact/semantic deduplication (MinHash LSH), language detection, quality classification.
+ - **Image:** CLIP embeddings, aesthetic filtering, NSFW detection, deduplication.
+ - **Video:** Scene detection (TransNetV2), clip extraction, motion/aesthetic filtering, GPU H.264 encoding, Cosmos-Embed1 embeddings.
+ - **Audio:** ASR transcription, WER filtering, quality assessment.
+ - Powered by **NVIDIA RAPIDS** (cuDF, cuML, cuGraph) + Ray for multi-node scaling.
+ - Proven results: 16x faster fuzzy dedup on 8 TB dataset; 40% lower TCO vs CPU.
+- **Docs:** [docs.nvidia.com/nemo/oss/curator](https://docs.nvidia.com/nemo/oss/curator/latest/)
+- **Container:** [NGC NeMo Curator](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-curator)
+
+### 3b. NeMo Data Designer
+
+
+
+- **Repo:** [NVIDIA-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner) — 698 stars
+- **What it does:** Generate high-quality **synthetic datasets** from scratch or from seed data.
+- **Highlights for writers:**
+ - Statistical samplers for controlled distributions (category, numeric, etc.).
+ - LLM-powered text generation columns with dependency-aware field generation.
+ - Built-in validators (Python, SQL, custom) and LLM-as-a-judge scoring.
+ - Preview mode for fast iteration before full-scale generation.
+ - Supports NVIDIA Build API, OpenAI, OpenRouter, and custom providers.
+ - CLI for model/provider configuration (`data-designer config`).
+ - Collects anonymized telemetry on model usage (opt-out available).
+- **Docs:** [nvidia-nemo.github.io/DataDesigner](https://nvidia-nemo.github.io/DataDesigner/latest/)
+
+### 3c. NeMo Skills (Data Side)
+
+
+
+- **Repo:** [NVIDIA-NeMo/Skills](https://github.com/NVIDIA-NeMo/Skills) — 816 stars
+- **What it does:** Synthetic data generation pipelines for math, code, and science datasets.
+- **Highlights for writers:**
+ - End-to-end SDG pipelines: generate → filter → train → evaluate.
+ - Released major open datasets: OpenMathInstruct-2 (14M pairs), OpenMathReasoning (3.2M CoT solutions), OpenScienceReasoning-2.
+ - Flexible LLM inference: API providers, local servers, large-scale SLURM jobs.
+ - Host models with TensorRT-LLM, vLLM, SGLang, or Megatron.
+- **Docs:** [nvidia-nemo.github.io/Skills](https://nvidia-nemo.github.io/Skills/)
+
+---
+
+## 4. Training Stage
+
+### 4a. NeMo AutoModel (Primary — up to ~1K GPUs)
+
+- **Repo:** [NVIDIA-NeMo/Automodel](https://github.com/NVIDIA-NeMo/Automodel) — 288 stars
+- **What it does:** PyTorch DTensor-native SPMD training library for LLMs and VLMs with out-of-the-box Hugging Face support.
+- **Highlights for writers:**
+ - **SPMD philosophy:** Same script runs on 1 GPU or 1000+ — parallelism is configuration, not code rewrites.
+ - **YAML-driven recipes** with CLI overrides for any field.
+ - **Supported tasks:** Pretraining, SFT, LoRA (PEFT), Knowledge Distillation.
+ - **Model coverage (LLM):** Llama 3.x, Qwen 2.5/3, DeepSeek V3/V3.2, Gemma 2/3, Mistral/Mixtral, Phi 2/3/4, GPT-OSS, Nemotron, Moonlight, Baichuan, Seed, GLM, MiniMax, Step — essentially *any* HF causal LM.
+ - **Model coverage (VLM):** Gemma 3 VL, Gemma 3n VL, Qwen2.5 VL, Qwen3 VL 235B, Kimi K2.5 VL.
+ - **Parallelism:** FSDP2, Tensor Parallel, Context Parallel, Sequence Parallel, Pipeline Parallel (3D parallelism).
+ - **Performance features:** FP8 via torchao, sequence packing, distributed checkpointing (SafeTensors).
+ - **Performance numbers:** DeepSeek V3 671B → 250 TFLOPs/GPU on 256 GPUs; GPT-OSS 20B → 279 TFLOPs/GPU.
+ - Actively developed — new model support weekly (MiniMax-M2, DeepSeek V3.2, Step 3.5-flash in Feb 2026).
+ - Install: `pip install nemo-automodel` or `uv sync`.
+ - **Launch options:** `torchrun`, `automodel` CLI (interactive + SLURM), Kubernetes (coming).
+- **Docs:** [docs.nvidia.com/nemo/oss/automodel](https://docs.nvidia.com/nemo/oss/automodel/latest/)
+- **Container:** [NGC NeMo AutoModel](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-automodel)
+
+### 4b. NeMo Megatron-Bridge (Scale — 1K+ GPUs)
+
+- **Repo:** [NVIDIA-NeMo/Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) — 423 stars
+- **What it does:** Training library that bridges Hugging Face and [Megatron-Core](https://github.com/NVIDIA/Megatron-LM/tree/main/megatron/core) for maximum throughput at extreme scale.
+- **Highlights for writers:**
+ - **Core capability:** Bidirectional checkpoint conversion between HF and Megatron formats — online, parallelism-aware, memory-efficient.
+ - **`AutoBridge` API:** Auto-detect model architecture, convert, and materialize Megatron models in a few lines of Python.
+ - **Supported parallelisms:** TP, PP, VPP, CP, EP, ETP — 6D parallelism for near-linear scaling to thousands of nodes.
+ - **Training features:** Pretraining, SFT, LoRA/DoRA (PEFT), FP8/BF16/FP4 mixed precision.
+ - **Model coverage:** Llama 2–3.3, Qwen 2–3 (incl. MoE and VL), DeepSeek V2/V3, Gemma/Gemma 3 VL, Nemotron-H, Nemotron Nano v2/VL, GPT-OSS, GLM-4.5, Mistral/Ministral, Moonlight, OlMoE.
+ - **PyTorch-native training loop** — refactored from the legacy NeMo training stack for greater flexibility.
+ - Community adoptions: VeRL, Slime, SkyRL, Mind Lab (trained trillion-parameter GRPO LoRA on 64 H800s).
+- **Docs:** [docs.nvidia.com/nemo/oss/megatron-bridge](https://docs.nvidia.com/nemo/oss/megatron-bridge/latest/)
+- **Container:** [NGC NeMo Framework](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo)
+
+### 4c. NeMo Speech
+
+- **Repo:** [NVIDIA-NeMo/NeMo](https://github.com/NVIDIA-NeMo/NeMo)
+- **What it does:** Pretraining and SFT for speech AI models (ASR, TTS) using Megatron-Core.
+- **Highlights for writers:**
+ - Covers automatic speech recognition (ASR) and text-to-speech (TTS).
+ - Built on Megatron-Core backend.
+ - Part of the original NeMo monorepo, now housing the speech-specific workloads.
+- **Docs:** [docs.nvidia.com/nemo-framework (Speech AI)](https://docs.nvidia.com/nemo-framework/user-guide/latest/speech_ai/index.html)
+
+### 4d. NeMo DFM (Diffusion Foundation Models)
+
+- **Repo:** [NVIDIA-NeMo/DFM](https://github.com/NVIDIA-NeMo/DFM) — 29 stars
+- **What it does:** Training and inference for diffusion models (video, image, text generation).
+- **Highlights for writers:**
+ - **Dual-path architecture:** Megatron Bridge path (max scalability) and AutoModel path (easy experimentation).
+ - **Supported models:** DiT (Diffusion Transformers), WAN 2.1 (World Action Networks for video).
+ - Features: Flow Matching, EDM samplers, sequence packing, distributed checkpointing.
+ - YAML-driven recipes, `uv run` for reproducible environments.
+- **Docs:** [github.com/NVIDIA-NeMo/DFM/docs](https://github.com/NVIDIA-NeMo/DFM/tree/main/docs)
+
+### 4e. Emerging-Optimizers
+
+- **Repo:** [NVIDIA-NeMo/Emerging-Optimizers](https://github.com/NVIDIA-NeMo/Emerging-Optimizers)
+- **What it does:** Collection of cutting-edge optimizers (e.g., Muon, Dion) for use across training libraries.
+- **Docs:** [docs.nvidia.com/nemo/oss/emerging-optimizers](https://docs.nvidia.com/nemo/oss/emerging-optimizers/latest/index.html)
+
+---
+
+## 5. Alignment Stage
+
+### 5a. NeMo RL
+
+- **Repo:** [NVIDIA-NeMo/RL](https://github.com/NVIDIA-NeMo/RL) — 1,306 stars (most-starred in the org)
+- **What it does:** Scalable post-training library for reinforcement learning on LLMs and VLMs.
+- **Highlights for writers:**
+ - **Algorithms:** GRPO, GSPO, DAPO, DPO, SFT (w/ LoRA), Reward Modeling (RM), On-policy Distillation.
+ - **Multi-turn RL:** Tool use, games, multi-step environments.
+ - **Async RL:** Asynchronous rollouts + replay buffers for fully async GRPO.
+ - **Two training backends:**
+ - **DTensor** (PyTorch-native FSDP2, TP, CP, SP, PP) — via NeMo AutoModel.
+ - **Megatron-Core** (6D parallelism) — via Megatron-Bridge.
+ - **Two generation backends:** vLLM and Megatron Inference.
+ - **End-to-end FP8** training + FP8 vLLM generation.
+ - **VLM support:** SFT and GRPO for vision-language models.
+ - Ray-based infrastructure for resource management and worker isolation.
+ - Used to train [Nemotron-3-Nano-30B](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-FP8).
+ - Latest release: v0.5.0 (Jan 2026) with LoRA support for DTensor and Megatron backends.
+ - Install: `uv venv && uv run python examples/run_grpo.py`
+- **Docs:** [docs.nvidia.com/nemo/oss/rl](https://docs.nvidia.com/nemo/oss/rl/latest/)
+- **Container:** [NGC NeMo RL](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-rl)
+
+### 5b. NeMo Gym
+
+- **Repo:** [NVIDIA-NeMo/Gym](https://github.com/NVIDIA-NeMo/Gym) — 637 stars
+- **What it does:** Build RL training environments for LLMs — provides infrastructure to develop environments, scale rollout collection, and integrate with training frameworks.
+- **Highlights for writers:**
+ - Scaffolding for multi-step, multi-turn, and user-modeling RL scenarios.
+ - Growing collection of **resource servers** (training environments):
+ - **Agent:** Calendar scheduling, Google Search, Workplace Assistant, Math Advanced Calculations.
+ - **Coding:** Competitive coding (Code Gen), Mini SWE Agent (SWE-bench style).
+ - **Knowledge:** MCQA (MMLU/GPQA/HLE style).
+ - **Math:** Math with Judge (OpenMathReasoning dataset).
+ - **Instruction following:** IFEval/IFBench style + Structured Outputs.
+ - Each resource server ships with datasets, configs, tests, and a README.
+ - Integrates with NeMo RL and other training frameworks.
+ - Responses API-based agent architecture.
+ - Early development — APIs evolving.
+- **Docs:** [docs.nvidia.com/nemo/oss/gym](https://docs.nvidia.com/nemo/oss/gym/latest/index.html)
+
+---
+
+## 6. Evaluation Stage
+
+### 6a. NeMo Evaluator
+
+- **Repo:** [NVIDIA-NeMo/Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) — 195 stars
+- **What it does:** Open-source platform for robust, reproducible, and scalable LLM evaluation across 100+ benchmarks.
+- **Highlights for writers:**
+ - **Two components:**
+ - `nemo-evaluator` — core engine that manages harness ↔ model interaction.
+ - `nemo-evaluator-launcher` — CLI/orchestration layer that handles config, environment selection, and container launch.
+ - **18 evaluation harnesses** with pre-built NGC containers:
+ - Language: lm-evaluation-harness (MMLU, GSM8K, ARC, BBH, IFEval, etc.), simple-evals (MATH-500, AIME, HumanEval).
+ - Code: bigcode-evaluation-harness (MBPP, HumanEval+), livecodebench, compute-eval (CUDA), scicode.
+ - Safety: garak (vulnerability testing), safety-harness (Aegis v2, WildGuard).
+ - VLM: vlmevalkit (MMMU, ChartQA, MathVista, OCRBench).
+ - Specialized: BFCL (function calling), MT-Bench, TAU2-Bench, RULER (long-context), CoDec (contamination detection), MTEB (embeddings).
+ - Works with any **OpenAI-compatible endpoint** — hosted (build.nvidia.com, NIM) or self-hosted (vLLM, TRT-LLM).
+ - **Reproducibility by default:** All configs, seeds, and software provenance captured automatically.
+ - **Scale anywhere:** Local machine, SLURM, Lepton AI, cloud-native backends.
+ - Install: `pip install nemo-evaluator-launcher`
+- **Docs:** [docs.nvidia.com/nemo/oss/evaluator](https://docs.nvidia.com/nemo/oss/evaluator/latest/)
+
+### 6b. NeMo Skills (Evaluation Side)
+
+- Skills also provides evaluation pipelines across math (AIME 24/25, HMMT), code (SWE-bench, LiveCodeBench), science (HLE, SciCode, GPQA), instruction following (IFBench, IFEval), long-context (RULER), VLM (MMMU-Pro), and more.
+- Easy to parallelize evaluations across SLURM jobs and self-host LLM judges.
+
+---
+
+## 7. Deployment Stage
+
+### 7a. NeMo Export-Deploy
+
+- **Repo:** [NVIDIA-NeMo/Export-Deploy](https://github.com/NVIDIA-NeMo/Export-Deploy) — 27 stars
+- **What it does:** Export NeMo and HF models to optimized inference backends and deploy for efficient serving.
+- **Highlights for writers:**
+ - **Export targets:** TensorRT-LLM, vLLM, ONNX, TensorRT.
+ - **Deployment options:** NVIDIA Triton Inference Server (PyTriton) and Ray Serve.
+ - **Model support:** NeMo LLMs, NeMo Multimodal, Hugging Face models, NIM Embedding, NIM Reranking.
+ - **Precision:** BF16, FP8, INT8 (PTQ, QAT), FP4 (coming soon).
+ - **Multi-GPU / Multi-instance** deployment support.
+ - Serves as the bridge from training to production inference.
+ - Install: `pip install nemo-export-deploy` (lightweight) or use NeMo Framework container for full features.
+- **Docs:** [docs.nvidia.com/nemo/oss/export-deploy](https://docs.nvidia.com/nemo/oss/export-deploy/latest/)
+- **Container:** Included in [NGC NeMo Framework](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo)
+
+### 7b. NeMo Guardrails
+
+- **Repo:** [NVIDIA-NeMo/Guardrails](https://github.com/NVIDIA-NeMo/Guardrails) — 5,635 stars (highest in the org!)
+- **What it does:** Open-source toolkit for adding programmable guardrails to LLM-based conversational applications.
+- **Highlights for writers:**
+ - **5 types of rails:** Input, Dialog, Retrieval, Execution, Output.
+ - **Colang language** (Python-like DSL) for defining dialog flows and rails — two versions: 1.0 and 2.0.
+ - **Built-in guardrails library:** Jailbreak detection, fact-checking, hallucination detection, content moderation (Aegis, ActiveFence), sensitive data masking.
+ - **Use cases:** RAG fact-checking, domain assistants, LLM endpoint safety, LangChain integration.
+ - Works with OpenAI, Llama, Falcon, Vicuna, Mosaic, and more.
+ - CLI: `nemoguardrails chat`, `nemoguardrails server`, `nemoguardrails evaluate`.
+ - OpenAI-compatible server endpoint at `/v1/chat/completions`.
+ - Published in EMNLP 2023 — academic paper available.
+ - Latest version: 0.20.0.
+- **Docs:** [docs.nvidia.com/nemo/oss/guardrails](https://docs.nvidia.com/nemo/oss/guardrails)
+
+---
+
+## 8. Infrastructure & Tooling
+
+### 8a. NeMo Run
+
+- **Repo:** [NVIDIA-NeMo/Run](https://github.com/NVIDIA-NeMo/Run) — 216 stars
+- **What it does:** Configure, launch, and manage ML experiments across computing environments.
+- **Highlights for writers:**
+ - **Three core responsibilities:** Configuration, Execution, Management.
+ - **Pythonic:** Everything configured in Python — no need for multi-tool workflows.
+ - **Executors:** LocalExecutor, SlurmExecutor, SkypilotExecutor — set up once, scale easily.
+ - **Modular:** Decouple task from executor; reuse environment configs across tasks.
+ - Built on Fiddle (Google), TorchX, Skypilot, XManager.
+ - Pre-release — API subject to change before v1.0.
+- **Docs:** [docs.nvidia.com/nemo/oss/run](https://docs.nvidia.com/nemo/oss/run/latest/)
+
+### 8b. Nemotron (Models & Recipes)
+
+- **Repo:** [NVIDIA-NeMo/Nemotron](https://github.com/NVIDIA-NeMo/Nemotron)
+- **What it does:** Recipes and scripts for NVIDIA's Nemotron model family.
+- Contains training recipes, configuration files, and documentation for reproducing Nemotron models.
+
+---
+
+## 9. How the Repos Connect — Interoperability Map
+
+
+
+| From | To | How |
+|------|----|-----|
+| **Curator** → Training | Curated datasets feed into AutoModel / Megatron-Bridge / RL |
+| **Data Designer** → Training | Synthetic data generation → SFT / RLHF datasets |
+| **Skills** → Training / Eval | SDG pipelines + evaluation benchmarks |
+| **AutoModel** ↔ **HF Hub** | Day-0 support — no checkpoint conversion needed |
+| **AutoModel** → **NeMo RL** | Checkpoints used directly as starting points for DPO/GRPO |
+| **Megatron-Bridge** ↔ **HF Hub** | Bidirectional checkpoint conversion via `AutoBridge` |
+| **Megatron-Bridge** → **NeMo RL** | Megatron-Core training backend for RL at scale |
+| **NeMo Gym** → **NeMo RL** | RL environments provide training data + reward signals |
+| **Training** → **Evaluator** | Evaluate trained models against 100+ benchmarks |
+| **Training** → **Export-Deploy** | Export to TRT-LLM / vLLM / ONNX for production |
+| **Export-Deploy** → **Guardrails** | Add safety rails on top of deployed models |
+| **NeMo Run** → All | Experiment launcher for any library across local/SLURM/K8s |
+
+---
+
+## 10. NGC Containers Quick Reference
+
+| Container | Key Libraries Included |
+|-----------|----------------------|
+| [NeMo Framework](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo) | Megatron-Bridge, Export-Deploy, Evaluator, Run |
+| [NeMo AutoModel](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-automodel) | AutoModel |
+| [NeMo RL](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-rl) | NeMo RL (+ vLLM, Megatron) |
+| [NeMo Curator](https://catalog.ngc.nvidia.com/orgs/nvidia/containers/nemo-curator) | Curator + RAPIDS |
+
+---
+
+## 11. Key Themes for Technical Writers
+
+1. **Two training paths story:** AutoModel (PyTorch-native, easy HF, up to ~1K GPUs) vs. Megatron-Bridge (Megatron-Core, 6D parallelism, 1K+ GPUs). Several repos (DFM, RL) support both backends — consistent messaging is important.
+2. **Day-0 HF support:** A major selling point. Both AutoModel and Megatron-Bridge work with HF models — but the mechanism differs (DTensor native vs. `AutoBridge` conversion).
+3. **YAML-driven recipes:** AutoModel, Megatron-Bridge, RL, and DFM all follow a YAML config + CLI override pattern. Docs should be consistent in how they describe this.
+4. **`uv` as the package manager:** Several repos have adopted `uv` for reproducible environments. Writers should document `uv venv`, `uv sync`, `uv run` patterns.
+5. **Scale spectrum:** The framework spans from `pip install` on a laptop to 10K+ GPU SLURM clusters. Docs should provide clear paths for each scale.
+6. **Multi-repo cross-references:** Many workflows span 2+ repos (e.g., Curator → AutoModel → RL → Evaluator → Export-Deploy). Cross-linking and journey-based docs are critical.
+7. **Active development:** Several repos (AutoModel, RL, Gym) are under heavy active development with weekly model additions. Docs need processes for rapid updates.
+
+---
+
+## 12. Suggested Discussion / Q&A Topics
+
+- How should we handle cross-repo documentation? (Unified getting-started guide vs. per-repo docs)
+- What is the versioning/release cadence across repos?
+- Which repos are highest priority for documentation investment?
+- How do we keep model support tables current?
+- Should we have a shared glossary across all NeMo docs sites?
+- Container documentation: one page per container or integrated into each repo's docs?
+
+---
+
+## Appendix: Repo Summary Table
+
+| Repo | Stage | Stars | One-Liner | Docs |
+|------|-------|-------|-----------|------|
+| [Curator](https://github.com/NVIDIA-NeMo/Curator) | Data | 1,394 | GPU-accelerated data curation (text, image, video, audio) | [link](https://docs.nvidia.com/nemo/oss/curator/latest/) |
+| [Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner) | Data | 698 | Synthetic data generation from scratch or seed data | [link](https://nvidia-nemo.github.io/DataDesigner/latest/) |
+| [Skills](https://github.com/NVIDIA-NeMo/Skills) | Data + Eval | 816 | SDG pipelines + evaluation for math, code, science | [link](https://nvidia-nemo.github.io/Skills/) |
+| [AutoModel](https://github.com/NVIDIA-NeMo/Automodel) | Training | 288 | PyTorch DTensor-native training with HF support | [link](https://docs.nvidia.com/nemo/oss/automodel/latest/) |
+| [Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) | Training | 423 | Megatron-Core training with bidirectional HF conversion | [link](https://docs.nvidia.com/nemo/oss/megatron-bridge/latest/) |
+| [NeMo (Speech)](https://github.com/NVIDIA-NeMo/NeMo) | Training | — | Speech AI (ASR, TTS) on Megatron-Core | [link](https://docs.nvidia.com/nemo-framework/user-guide/latest/speech_ai/index.html) |
+| [DFM](https://github.com/NVIDIA-NeMo/DFM) | Training | 29 | Diffusion model training (video, image) | [link](https://github.com/NVIDIA-NeMo/DFM/tree/main/docs) |
+| [Emerging-Optimizers](https://github.com/NVIDIA-NeMo/Emerging-Optimizers) | Training | — | Collection of cutting-edge optimizers | [link](https://docs.nvidia.com/nemo/oss/emerging-optimizers/latest/) |
+| [NeMo RL](https://github.com/NVIDIA-NeMo/RL) | Alignment | 1,306 | Scalable post-training (GRPO, DPO, SFT, distillation) | [link](https://docs.nvidia.com/nemo/oss/rl/latest/) |
+| [Gym](https://github.com/NVIDIA-NeMo/Gym) | Alignment | 637 | RL environments for LLM training | [link](https://docs.nvidia.com/nemo/oss/gym/latest/) |
+| [Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) | Evaluation | 195 | 100+ benchmarks across 18 harnesses | [link](https://docs.nvidia.com/nemo/oss/evaluator/latest/) |
+| [Export-Deploy](https://github.com/NVIDIA-NeMo/Export-Deploy) | Deployment | 27 | Export to TRT-LLM/vLLM/ONNX + Triton serving | [link](https://docs.nvidia.com/nemo/oss/export-deploy/latest/) |
+| [Guardrails](https://github.com/NVIDIA-NeMo/Guardrails) | Deployment | 5,635 | Programmable safety rails with Colang DSL | [link](https://docs.nvidia.com/nemo/oss/guardrails) |
+| [Run](https://github.com/NVIDIA-NeMo/Run) | Infra | 216 | Experiment launcher (local, SLURM, K8s) | [link](https://docs.nvidia.com/nemo/oss/run/latest/) |
+| [Nemotron](https://github.com/NVIDIA-NeMo/Nemotron) | Recipes | — | Nemotron model family recipes | [link](https://github.com/NVIDIA-NeMo/Nemotron#readme) |
diff --git a/nemo-fw-product-walkthrough.md b/nemo-fw-product-walkthrough.md
new file mode 100644
index 0000000..5965bb3
--- /dev/null
+++ b/nemo-fw-product-walkthrough.md
@@ -0,0 +1,546 @@
+# NeMo Framework: Product Walkthrough
+
+> **Audience:** Technical writing team (all levels)
+> **Goal:** Understand what each product is, who it's for, and where it fits
+> **Not covered here:** Deep implementation details, parallelism internals, benchmark methodology
+
+---
+
+## What Is NeMo Framework?
+
+NeMo Framework is NVIDIA's open-source platform for building generative AI models. It covers the **entire model lifecycle** — from preparing training data, to training models, to making them safer and smarter, to evaluating quality, to deploying them in production.
+
+Think of it as a **toolbox with specialized tools for each stage**, not a single monolithic product. Each tool is a separate project (repo) with its own docs, and they're designed to work together.
+
+**The lifecycle in plain terms:**
+
+```
+Prepare Data → Train the Model → Align / Improve → Evaluate Quality → Deploy to Production
+```
+
+
+
+---
+
+## Quick Reference
+
+| # | Product | One-Line Summary | Stage | Docs |
+|---|---------|-----------------|-------|------|
+| 1 | [AutoModel](#1-automodel) | Fine-tune AI models with minimal setup | Training | [docs](https://docs.nvidia.com/nemo/oss/automodel/latest/) |
+| 2 | [Curator](#2-curator--video-curator) | Clean and filter training data at scale | Data | [docs](https://docs.nvidia.com/nemo/oss/curator/latest/) |
+| 3 | [Customizer](#3-customizer) | Fine-tune models via API (managed service) | Training | Product docs |
+| 4 | [Data Designer](#4-data-designer) | Generate synthetic training data | Data | [docs](https://nvidia-nemo.github.io/DataDesigner/latest/) |
+| 5 | [Evaluator](#5-evaluator) | Benchmark model quality across 100+ tests | Evaluation | [docs](https://docs.nvidia.com/nemo/oss/evaluator/latest/) |
+| 6 | [Gym](#6-gym) | Build practice environments for RL training | Alignment | [docs](https://docs.nvidia.com/nemo/oss/gym/latest/) |
+| 7 | [MCORE](#7-mcore-megatron-core) | Low-level engine for large-scale training | Training (engine) | [docs](https://docs.nvidia.com/Megatron-Core/) |
+| 8 | [Megatron-Bridge](#8-megatron-bridge) | Train at massive scale (1,000+ GPUs) | Training | [docs](https://docs.nvidia.com/nemo/oss/megatron-bridge/latest/) |
+| 9 | [nvFSDP](#9-nvfsdp) | Memory-efficient training technique inside AutoModel | Training (component) | [docs](https://docs.nvidia.com/nemo/oss/automodel/latest/) |
+| 10 | [RL](#10-rl) | Improve models using reinforcement learning | Alignment | [docs](https://docs.nvidia.com/nemo/oss/rl/latest/) |
+| 11 | [Toolkit (Speech)](#11-toolkit-speech) | Train speech recognition and text-to-speech models | Training | [docs](https://docs.nvidia.com/nemo-framework/user-guide/latest/speech_ai/index.html) |
+
+---
+
+## Key Terms
+
+A short glossary for terms that come up repeatedly across products.
+
+| Term | Plain-English Meaning |
+|------|----------------------|
+| **Fine-tuning** | Teaching an existing AI model new skills using your own data |
+| **SFT (Supervised Fine-Tuning)** | Fine-tuning by showing the model examples of correct answers |
+| **LoRA** | A memory-efficient way to fine-tune — updates a small slice of the model instead of the whole thing |
+| **RLHF / RL** | Reinforcement Learning — improving a model by giving it feedback (rewards) on its outputs |
+| **DPO / GRPO** | Specific RL techniques for aligning model behavior with human preferences |
+| **Pretraining** | Training a model from scratch on a large dataset (expensive, rare) |
+| **Inference** | Running a trained model to get predictions / answers |
+| **Hugging Face (HF)** | The most popular open platform for sharing AI models — NeMo works with HF models directly |
+| **NGC** | NVIDIA's container registry — pre-built Docker images optimized for NVIDIA hardware |
+| **NIM** | NVIDIA Inference Microservices — a way to deploy models as ready-to-use API endpoints |
+| **Checkpoint** | A saved snapshot of a model's learned knowledge (like a save file in a video game) |
+
+---
+
+## 1. AutoModel
+
+
+
+**Repo:** [NVIDIA-NeMo/Automodel](https://github.com/NVIDIA-NeMo/Automodel) | **Docs:** [docs.nvidia.com/nemo/oss/automodel](https://docs.nvidia.com/nemo/oss/automodel/latest/)
+
+### What Is It?
+
+AutoModel is the **easiest way to fine-tune AI models on NVIDIA GPUs**. You pick a model from Hugging Face, provide your data, and AutoModel handles the distributed training — whether you have 1 GPU or hundreds.
+
+### How Does It Work?
+
+1. You choose a model from Hugging Face (Llama, Qwen, DeepSeek, Gemma, Mistral, etc.)
+2. You write a short YAML config file describing your training job
+3. You run one command — AutoModel figures out how to split the work across your GPUs
+
+The key idea: **the same script works on any scale**. You don't rewrite code when you go from a laptop to a cluster.
+
+### Use Cases
+
+- Fine-tune a language model on company-specific data (support tickets, legal docs, medical records)
+- Train a vision-language model to understand your domain's images
+- Run LoRA (lightweight) fine-tuning when GPU memory is limited
+- Pretrain a model from scratch on a custom dataset
+
+### Where It's Positioned
+
+AutoModel is the **recommended starting point** for most training tasks. It works natively with Hugging Face models — no format conversion needed. If you outgrow it (need 1,000+ GPUs), you move to Megatron-Bridge.
+
+### Writer Notes
+
+- Very actively developed — new model support added weekly
+- Uses `uv` as its package manager (not just pip)
+- Checkpoints from AutoModel plug directly into NeMo RL for alignment
+
+---
+
+## 2. Curator / Video Curator
+
+
+
+**Repo:** [NVIDIA-NeMo/Curator](https://github.com/NVIDIA-NeMo/Curator) | **Docs:** [docs.nvidia.com/nemo/oss/curator](https://docs.nvidia.com/nemo/oss/curator/latest/)
+
+### What Is It?
+
+Curator is a **data cleaning and filtering toolkit** for AI training data. "Garbage in, garbage out" — Curator helps you go in with quality data across text, images, video, and audio.
+
+### How Does It Work?
+
+Curator runs GPU-accelerated pipelines that process raw data through stages:
+
+1. **Ingest** — Load data from files, web crawls, or storage
+2. **Filter & Classify** — Remove low-quality, duplicate, or unsafe content
+3. **Deduplicate** — Find and remove near-identical content (even fuzzy matches)
+4. **Output** — Clean, curated dataset ready for training
+
+It works on four data types:
+
+| Data Type | What Curator Does |
+|-----------|-------------------|
+| **Text** | Filters by quality, detects language, removes duplicates, classifies content |
+| **Image** | Scores visual quality, detects inappropriate content, removes duplicates |
+| **Video** | Detects scene changes, extracts clips, filters by motion/quality, deduplicates |
+| **Audio** | Transcribes speech, checks transcription quality, filters by accuracy |
+
+**Video Curator** is not a separate product — it's the video pipeline within the same Curator library.
+
+### Use Cases
+
+- Clean a web-crawled text dataset before training a language model
+- Filter a large image collection for training a vision model
+- Process raw video footage into training clips for a video generation model
+- Prepare audio datasets for speech recognition training
+
+### Where It's Positioned
+
+Curator sits at the **very beginning of the pipeline** — before any training happens. Its output feeds into AutoModel, Megatron-Bridge, or any other training tool. It's especially valuable at scale (terabytes of data) where GPU acceleration matters most.
+
+### Writer Notes
+
+- Docs are organized by modality: text, image, video, audio — each has its own getting-started guide
+- Video Curator is part of the same `nemo-curator` pip package
+- Powered by NVIDIA RAPIDS (GPU data processing libraries) + Ray (distributed computing)
+
+---
+
+## 3. Data Designer
+
+
+
+**Repo:** [NVIDIA-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner) | **Docs:** [nvidia-nemo.github.io/DataDesigner](https://nvidia-nemo.github.io/DataDesigner/latest/)
+
+### What Is It?
+
+Data Designer is a **synthetic data generation** tool. When you don't have enough real training data — or need data with specific properties — Data Designer creates it for you using a combination of statistical rules and LLM generation.
+
+### How Does It Work?
+
+You define a "schema" for the data you want:
+
+1. **Define columns** — Some are generated by statistical rules (e.g., "pick a random product category"), others are generated by an LLM (e.g., "write a customer review for this category")
+2. **Set dependencies** — One column's output can feed into another's prompt (so a review matches its category)
+3. **Validate** — Built-in validators check that generated data meets your quality rules
+4. **Preview → Generate** — Test with a small sample, then scale up
+
+### Use Cases
+
+- Generate training data for a chatbot when you have few real conversations
+- Create diverse test datasets for model evaluation
+- Build domain-specific instruction-following datasets
+- Augment limited real-world data with synthetic examples
+
+### Where It's Positioned
+
+Data Designer sits alongside Curator in the **data preparation stage** — but they solve different problems. Curator *cleans existing data*; Data Designer *creates new data*. They're complementary.
+
+### Writer Notes
+
+- Docs are hosted on GitHub Pages (`nvidia-nemo.github.io`), not `docs.nvidia.com`
+- Supports NVIDIA, OpenAI, and OpenRouter as LLM providers
+- Has a CLI for configuration: `data-designer config`
+
+---
+
+## 4. Evaluator
+
+
+
+**Repo:** [NVIDIA-NeMo/Evaluator](https://github.com/NVIDIA-NeMo/Evaluator) | **Docs:** [docs.nvidia.com/nemo/oss/evaluator](https://docs.nvidia.com/nemo/oss/evaluator/latest/)
+
+### What Is It?
+
+Evaluator is a **benchmarking platform** for testing how well AI models perform. It runs your model against 100+ standardized tests (benchmarks) and gives you reproducible scores.
+
+### How Does It Work?
+
+1. You point Evaluator at your model (any model that exposes a chat/completion API)
+2. You pick which benchmarks to run (math, code, safety, general knowledge, etc.)
+3. Evaluator pulls the right test container, runs the benchmark, and reports results
+4. All configurations and seeds are saved so results are reproducible
+
+It has two parts:
+- **Launcher** (`nemo-evaluator-launcher`) — the CLI you interact with; handles setup and orchestration
+- **Engine** (`nemo-evaluator`) — runs the actual benchmark; most users don't touch this directly
+
+### Use Cases
+
+- Compare your fine-tuned model against the base model to measure improvement
+- Run a standard benchmark suite before releasing a model
+- Test for safety issues (jailbreak vulnerability, bias, hallucination)
+- Evaluate code generation, math reasoning, or multilingual capabilities
+
+### Where It's Positioned
+
+Evaluator sits **after training and alignment** — it answers "how good is this model?" It works with any model that has an OpenAI-compatible API, so it's not locked to NeMo-trained models.
+
+### Writer Notes
+
+- Users primarily interact with the launcher CLI, not the engine
+- Each benchmark runs in its own Docker container from NGC
+- Supports running on local machines, SLURM clusters, and cloud backends
+
+---
+
+## 5. Gym
+
+
+
+**Repo:** [NVIDIA-NeMo/Gym](https://github.com/NVIDIA-NeMo/Gym) | **Docs:** [docs.nvidia.com/nemo/oss/gym](https://docs.nvidia.com/nemo/oss/gym/latest/)
+
+### What Is It?
+
+Gym provides **practice environments** where AI models learn through trial and error (reinforcement learning). Think of it like a training simulator — the model takes actions, the environment gives feedback, and the model improves.
+
+### How Does It Work?
+
+Gym comes with pre-built **environments** ("resource servers") across different skill domains:
+
+| Domain | Example Environments | What the Model Practices |
+|--------|---------------------|-------------------------|
+| **Agent tasks** | Calendar scheduling, web search, workplace assistant | Multi-step tool use |
+| **Coding** | Competitive programming, software engineering | Writing and debugging code |
+| **Math** | Math problem solving with verification | Mathematical reasoning |
+| **Knowledge** | Multiple-choice Q&A | Factual knowledge (like MMLU) |
+| **Instruction following** | Format constraints, structured outputs | Following precise instructions |
+
+Each environment includes a dataset of problems, a way to verify answers, and integration with NeMo RL for training.
+
+### Use Cases
+
+- Train a model to use tools (search, calendar, APIs) through practice
+- Improve a model's math or coding skills with verifiable feedback
+- Build a custom environment for your domain-specific RL training
+- Collect training data (rollouts) for use with NeMo RL
+
+### Where It's Positioned
+
+Gym is a **companion to NeMo RL**. RL provides the training algorithms; Gym provides the practice environments. Together they handle the "alignment" stage of the pipeline.
+
+### Writer Notes
+
+- Early-stage project — APIs are still evolving
+- No GPU required for Gym itself (only for the model doing inference)
+- Each environment has its own README, config, and dataset
+
+---
+
+## 6. MCORE (Megatron-Core)
+
+**Repo:** [NVIDIA/Megatron-LM](https://github.com/NVIDIA/Megatron-LM) (inside `megatron/core/`) | **Docs:** [docs.nvidia.com/Megatron-Core](https://docs.nvidia.com/Megatron-Core/)
+
+### What Is It?
+
+Megatron-Core (MCORE) is the **engine under the hood** of several NeMo products. It provides the low-level building blocks for training very large models across many GPUs efficiently. Most users never interact with MCORE directly — they use it through Megatron-Bridge or NeMo RL.
+
+### How Does It Work?
+
+When you train a model that's too large to fit on a single GPU, MCORE splits the work across many GPUs using various strategies:
+
+- **Split the model** across GPUs (different layers on different GPUs)
+- **Split the data** across GPUs (each GPU processes different examples)
+- **Split individual layers** across GPUs (for very wide layers)
+
+It also provides optimized model architectures, efficient checkpointing (saving/loading model snapshots), and mixed-precision training to use less memory.
+
+### Use Cases
+
+- You're building a **custom training framework** and need high-performance distributed training primitives
+- You're a **framework developer** integrating with Megatron-based systems
+
+Most end users should use Megatron-Bridge or AutoModel instead.
+
+### Where It's Positioned
+
+MCORE is a **dependency**, not a standalone product for most users:
+
+```
+Users interact with: AutoModel ←or→ Megatron-Bridge ←or→ NeMo RL
+ ↓ ↓ ↓
+Under the hood: PyTorch MCORE MCORE
+ (DTensor) (Megatron-Core) (Megatron-Core)
+```
+
+### Writer Notes
+
+- Lives in the **NVIDIA/Megatron-LM** repo (different GitHub org than most NeMo repos)
+- 15,000+ GitHub stars — one of the most popular NVIDIA open-source projects
+- MCORE docs should be written for framework developers, not end users
+
+---
+
+## 7. Megatron-Bridge
+
+
+
+**Repo:** [NVIDIA-NeMo/Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge) | **Docs:** [docs.nvidia.com/nemo/oss/megatron-bridge](https://docs.nvidia.com/nemo/oss/megatron-bridge/latest/)
+
+### What Is It?
+
+Megatron-Bridge is a **training library for extreme scale** — designed for training runs on 1,000+ GPUs. It connects Hugging Face models with MCORE's powerful distributed training engine.
+
+### How Does It Work?
+
+The "bridge" metaphor is literal — it bridges two worlds:
+
+- **Hugging Face world:** Where models are shared, easy to use, and widely adopted
+- **Megatron world:** Where training is maximally optimized for NVIDIA hardware at massive scale
+
+Megatron-Bridge converts models between these formats (in both directions) and provides a training loop on top. You can:
+
+1. Start from a Hugging Face model
+2. Convert it to Megatron format (automatically, using the `AutoBridge` API)
+3. Train at massive scale with MCORE
+4. Convert back to Hugging Face format for sharing or deployment
+
+### Use Cases
+
+- Pretraining or fine-tuning at 1,000+ GPU scale where maximum throughput matters
+- Organizations that need Megatron-level performance but want Hugging Face compatibility
+- Converting between Hugging Face and Megatron checkpoint formats
+
+### Where It's Positioned
+
+Megatron-Bridge is the **heavy-duty training option** — complementary to AutoModel:
+
+| | AutoModel | Megatron-Bridge |
+|---|---|---|
+| **Best for** | Getting started, rapid iteration | Maximum scale and throughput |
+| **GPU sweet spot** | 1 to ~1,000 GPUs | 1,000+ GPUs |
+| **Model source** | Hugging Face (native) | Hugging Face (via conversion) |
+| **Underlying engine** | PyTorch (DTensor) | Megatron-Core |
+
+### Writer Notes
+
+- Refactored from the original NeMo training stack
+- Has been adopted by several community projects (VeRL, SkyRL, Slime)
+- Recipes for popular models live in `src/megatron/bridge/recipes/`
+
+---
+
+## 9. nvFSDP
+
+**Location:** Inside [AutoModel](https://github.com/NVIDIA-NeMo/Automodel) | **Docs:** [docs.nvidia.com/nemo/oss/automodel](https://docs.nvidia.com/nemo/oss/automodel/latest/)
+
+### What Is It?
+
+nvFSDP is **not a standalone product** — it's a component inside AutoModel that handles **memory-efficient distributed training**. It automatically splits a model's memory footprint across GPUs so you can train models that are too large to fit on a single GPU.
+
+### How Does It Work?
+
+In simple terms: instead of every GPU holding a full copy of the model, nvFSDP shards (splits) the model's weights, gradients, and optimizer state across all GPUs. Each GPU holds only a fraction, and they coordinate during training.
+
+This is NVIDIA's optimized version of PyTorch's FSDP2 (Fully Sharded Data Parallel) technology.
+
+### Use Cases
+
+- Training large models on limited GPU memory
+- Users don't interact with nvFSDP directly — they benefit from it automatically when using AutoModel
+
+### Where It's Positioned
+
+nvFSDP is an **implementation detail** of AutoModel. Users configure it through AutoModel's YAML settings. Writers may encounter the term in code or internal docs, but externally it's usually referred to as "FSDP2."
+
+### Writer Notes
+
+- Not a separate repo, pip package, or product — it's part of AutoModel's internals
+- The name "nvFSDP" may appear in internal docs; externally prefer "FSDP2" or "FSDP2 Strategy"
+- NeMo RL's DTensor backend also uses this under the hood (via AutoModel)
+
+---
+
+## 10. RL
+
+
+
+**Repo:** [NVIDIA-NeMo/RL](https://github.com/NVIDIA-NeMo/RL) | **Docs:** [docs.nvidia.com/nemo/oss/rl](https://docs.nvidia.com/nemo/oss/rl/latest/)
+
+### What Is It?
+
+NeMo RL is a **post-training library** that makes AI models better through reinforcement learning — the model generates outputs, gets feedback on quality, and learns to produce better results over time.
+
+### How Does It Work?
+
+The core loop:
+
+1. **Generate** — The model produces responses to prompts
+2. **Score** — A reward system evaluates the responses (correct math? followed instructions? safe output?)
+3. **Train** — The model updates its behavior based on the scores
+4. Repeat
+
+NeMo RL supports several training techniques:
+
+| Technique | What It Does |
+|-----------|-------------|
+| **GRPO** | Reinforcement learning using group-relative scoring — the main RL method |
+| **DPO** | Learns from pairs of "preferred vs. rejected" responses |
+| **SFT** | Standard supervised fine-tuning (also available here for convenience) |
+| **Distillation** | A smaller "student" model learns from a larger "teacher" model |
+| **Reward Modeling** | Trains a model to predict human preferences (used as the scorer) |
+
+### Use Cases
+
+- Improve a model's math and reasoning abilities using verified solutions
+- Align a model with human preferences (helpful, harmless, honest)
+- Train a model to use tools through multi-turn interaction
+- Distill a large model's capabilities into a smaller, cheaper model
+
+### Where It's Positioned
+
+RL covers the **alignment stage** — after initial training (AutoModel / Megatron-Bridge) and before evaluation. It works with:
+
+- **NeMo Gym** for practice environments and reward signals
+- **AutoModel** or **Megatron-Bridge** as its training engine (user picks via config)
+- **Evaluator** to measure improvement after alignment
+
+### Writer Notes
+
+- Most-starred repo in the NVIDIA-NeMo org (1,300+ stars)
+- Used to train NVIDIA's Nemotron-3-Nano-30B model
+- Training backend (AutoModel vs. Megatron) is selected automatically based on the YAML config
+- Uses Ray for distributed infrastructure
+
+---
+
+## 11. Toolkit (Speech)
+
+**Repo:** [NVIDIA-NeMo/NeMo](https://github.com/NVIDIA-NeMo/NeMo) | **Docs:** [docs.nvidia.com/nemo-framework (Speech AI)](https://docs.nvidia.com/nemo-framework/user-guide/latest/speech_ai/index.html)
+
+### What Is It?
+
+The NeMo Toolkit is the **speech AI** component of the framework, providing tools for training automatic speech recognition (ASR) and text-to-speech (TTS) models.
+
+### How Does It Work?
+
+- **ASR (Speech-to-Text):** Train models that convert spoken audio into text — supports multiple languages
+- **TTS (Text-to-Speech):** Train models that generate natural-sounding speech from text
+- Comes with a large collection of **pretrained models** that can be fine-tuned for specific domains, accents, or languages
+
+### Use Cases
+
+- Build a custom speech recognition system for a specific industry (medical, legal, call center)
+- Create a text-to-speech voice for a specific language or brand
+- Fine-tune an existing speech model on your organization's vocabulary
+
+### Where It's Positioned
+
+This is the **original NeMo repository**. Historically, it contained everything (LLM, speech, vision). Over time, LLM training was split into AutoModel and Megatron-Bridge. This repo now **primarily houses the speech workloads**.
+
+NeMo Curator's audio pipeline can prepare data that feeds into Toolkit (Speech) for training.
+
+### Writer Notes
+
+- The repo is named "NeMo" which can be confusing — "NeMo" (the repo) now means "speech," while "NeMo Framework" means the entire ecosystem
+- Docs live under the NeMo Framework User Guide, not a standalone site
+- This repo is large and historically complex — speech docs should be clearly scoped
+
+---
+
+## How the Products Connect
+
+
+
+Here's how data and models flow between the products:
+
+| Step | What Happens | Products Involved |
+|------|-------------|-------------------|
+| 1. **Prepare data** | Clean real data or generate synthetic data | Curator, Data Designer |
+| 2. **Train** | Fine-tune or pretrain a model | AutoModel (standard) or Megatron-Bridge (large scale) |
+| 3. **Align** | Improve the model with RL or preference learning | RL + Gym |
+| 4. **Evaluate** | Benchmark quality across standardized tests | Evaluator |
+| 5. **Deploy** | Export and serve the model in production | (Export-Deploy, Guardrails — not covered in this deck) |
+
+**Alternatively:** Use **Customizer** for steps 2–3 via API instead of running open-source code.
+
+**Under the hood:** MCORE powers Megatron-Bridge and RL's Megatron backend. nvFSDP powers AutoModel and RL's DTensor backend. **NeMo Run** (not covered in this deck) is an experiment launcher that works across all products.
+
+---
+
+## Comparison Cheat Sheet
+
+### "I want to train a model" — Which product?
+
+| Situation | Use This |
+|-----------|----------|
+| Fine-tune a Hugging Face model on my data | **AutoModel** |
+| Train at massive scale (1,000+ GPUs) | **Megatron-Bridge** |
+| Fine-tune via API without managing infrastructure | **Customizer** |
+| Train a speech recognition or TTS model | **Toolkit (Speech)** |
+
+### "I want to improve a trained model" — Which product?
+
+| Situation | Use This |
+|-----------|----------|
+| Align with human preferences (DPO, GRPO) | **RL** |
+| Train a model to use tools via practice | **RL + Gym** |
+| Distill a large model into a smaller one | **RL** (on-policy distillation) |
+
+### "I need training data" — Which product?
+
+| Situation | Use This |
+|-----------|----------|
+| Clean / filter / deduplicate existing data | **Curator** |
+| Generate synthetic data from scratch | **Data Designer** |
+
+---
+
+## Documentation Landscape
+
+Not all products are documented in the same place:
+
+| Docs Host | Products |
+|-----------|----------|
+| `docs.nvidia.com/nemo/oss/...` | AutoModel, Megatron-Bridge, RL, Gym, Evaluator, Curator |
+| `docs.nvidia.com/Megatron-Core/` | MCORE |
+| `nvidia-nemo.github.io/...` | Data Designer, Skills |
+| `docs.nvidia.com/nemo-framework/user-guide/...` | Toolkit (Speech) |
+
+### Open-Source vs. Managed
+
+| Type | Products |
+|------|----------|
+| **Open-source (GitHub)** | AutoModel, Curator, Data Designer, Evaluator, Gym, MCORE, Megatron-Bridge, RL, Toolkit |
+| **Closed-source (microservice)** | Customizer |
+| **Internal component** (not a standalone product) | nvFSDP |
diff --git a/profile/README.md b/profile/README.md
index 47f739c..d0503b8 100644
--- a/profile/README.md
+++ b/profile/README.md
@@ -1,92 +1,44 @@
-## NVIDIA NeMo Framework Overview
+# NeMo OSS
-NeMo Framework is NVIDIA's GPU accelerated, fully open-source, end-to-end training framework for large language models (LLMs), multi-modal models, diffusion and speech models. It enables seamless scaling of pretraining, post-training, and reinforcement learning workloads from single GPU to thousand-node clusters for both 🤗Hugging Face/PyTorch and Megatron models. This GitHub organization includes a suite of libraries and recipe collections to help users train models from end to end.
+Build generative AI models and agents on NVIDIA GPUs with open source NVIDIA NeMo libraries for data curation, training, alignment, evaluation, deployment, guardrails, and end-to-end recipes.
-NeMo Framework is also a part of the NVIDIA NeMo software suite for managing the AI agent lifecycle.
+NeMo OSS is part of the broader NVIDIA NeMo software suite. Use this GitHub organization for source code, examples, issue tracking, and repository-specific documentation.
-## Latest 📣 announcements and 🗣️ discussions
-### 🐳 NeMo AutoModel
-- [10/6/2025][Enabling PyTorch Native Pipeline Parallelism for 🤗 Hugging Face Transformer Models](https://github.com/NVIDIA-NeMo/Automodel/discussions/589)
-- [9/22/2025][Fine-tune Hugging Face Models Instantly with Day-0 Support with NVIDIA NeMo AutoModel](https://github.com/NVIDIA-NeMo/Automodel/discussions/477)
-- [9/18/2025][🚀 NeMo Framework Now Supports Google Gemma 3n: Efficient Multimodal Fine-tuning Made Simple](https://github.com/NVIDIA-NeMo/Automodel/discussions/494)
+## Start With a Repository
-### 🔬 NeMo RL
-- [10/1/2025][On-policy Distillation](https://github.com/NVIDIA-NeMo/RL/discussions/1445)
-- [9/27/2025][FP8 Quantization in NeMo RL](https://github.com/NVIDIA-NeMo/RL/discussions/1216)
-- [8/15/2025][NeMo-RL: Journey of Optimizing Weight Transfer in Large MoE Models by 10x](https://github.com/NVIDIA-NeMo/RL/discussions/1189)
+Use this table to choose a starting repository based on your workflow.
-### 💬 NeMo Speech
-- [8/1/2025][Guide to Fine-tune Nvidia NeMo models with Granary Data](https://github.com/NVIDIA-NeMo/NeMo/discussions/14758)
+| Workflow | Use For | Repositories |
+| --- | --- | --- |
+| **Data** | Curate, synthesize, anonymize, and prepare datasets | [Curator](https://github.com/NVIDIA-NeMo/Curator), [Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner), [Anonymizer](https://github.com/NVIDIA-NeMo/Anonymizer) |
+| **Pretraining** | Train, fine-tune, adapt, and convert model checkpoints | [AutoModel](https://github.com/NVIDIA-NeMo/Automodel), [Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge), [NeMo Speech](https://github.com/NVIDIA-NeMo/NeMo) |
+| **RL** | Run SFT, DPO, GRPO, RL, environments, and rollouts | [NeMo RL](https://github.com/NVIDIA-NeMo/RL), [Gym](https://github.com/NVIDIA-NeMo/Gym), [ProRL Agent Server](https://github.com/NVIDIA-NeMo/ProRL-Agent-Server) |
+| **Inference** | Evaluate, export, serve, and add guardrails | [Evaluator](https://github.com/NVIDIA-NeMo/Evaluator), [Export-Deploy](https://github.com/NVIDIA-NeMo/Export-Deploy), [Guardrails](https://github.com/NVIDIA-NeMo/Guardrails) |
+| **Agents** | Evaluate, secure, tune, and deploy agent workflows | [NeMo Platform](https://github.com/NVIDIA-NeMo/nemo-platform) |
+| **End-to-End** | Launch experiments, follow recipes, and use reference assets | [Run](https://github.com/NVIDIA-NeMo/Run), [Skills](https://github.com/NVIDIA-NeMo/Skills), [Nemotron](https://github.com/NVIDIA-NeMo/Nemotron) |
-More to come and stay tuned!
+## Choose NeMo Framework or NeMo Platform
-## Getting Started
+Use NeMo Framework for model lifecycle work, and use NeMo Platform for integrated agent workflows.
-||Installation|Checkpoint Conversion HF<>Megatron|LLM example recipes and scripts|VLM example recipes and scripts|
-|-|-|-|-|-|
-|1 ～ 1,000 GPUs|[NeMo Automodel](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#getting-started), [NeMo RL](https://github.com/NVIDIA-NeMo/RL?tab=readme-ov-file#prerequisites)|No Need|[Pre-training](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#llm-pre-training), [SFT](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#llm-supervised-fine-tuning-sft), [LoRA](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#llm-parameter-efficient-fine-tuning-peft), [DPO](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/run_dpo.py), [GRPO](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/run_grpo_math.py)|[SFT](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#vlm-supervised-fine-tuning-sft), [LoRA](https://github.com/NVIDIA-NeMo/Automodel?tab=readme-ov-file#vlm-parameter-efficient-fine-tuning-peft), [GRPO](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/run_vlm_grpo.py)
-|Over 1,000 GPUs|[NeMo Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge?tab=readme-ov-file#-installation), [NeMo RL](https://github.com/NVIDIA-NeMo/RL?tab=readme-ov-file#prerequisites)|[Conversion](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/examples/conversion/README.md)|[Pretrain, SFT, and LoRA](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/src/megatron/bridge/recipes/llama/llama3.py), [DPO](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/run_dpo.py) with [megatron_cfg](https://github.com/NVIDIA-NeMo/RL/blob/fa379fffbc9c5580301fa748dbba269c7d90f883/examples/configs/dpo.yaml#L99), [GRPO](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/run_grpo_math.py) with [megatron_cfg](https://github.com/NVIDIA-NeMo/RL/blob/fa379fffbc9c5580301fa748dbba269c7d90f883/examples/configs/grpo_math_1B_megatron.yaml#L79)|[SFT, LoRA](https://github.com/NVIDIA-NeMo/Megatron-Bridge/blob/main/src/megatron/bridge/recipes/qwen_vl/qwen25_vl.py), [GRPO megatron config](https://github.com/NVIDIA-NeMo/RL/blob/main/examples/configs/vlm_grpo_3B_megatron.yaml)|
+- **NeMo Framework** is the model-lifecycle stack: data, training, RL, evaluation, export, and deployment libraries across the repositories listed above.
+- **NeMo Platform** is the agent workflow entry point: [CLI, SDK, and Studio](https://github.com/NVIDIA-NeMo/nemo-platform) for evaluating, securing, tuning, and deploying agents.
-## Repo organization under NeMo Framework
+## Community
-### Summary of key functionalities and container strategy of each repo
+Use these links to ask questions, browse repositories, and follow open work.
-Visit the individual repos to find out more 🔍, raise :bug:, contribute ✍️ and participate in discussion forums 🗣️!
-
-Note: The NeMo Framework is currently in the process of restructuring. The original NeMo 2.0 repository will now focus specifically on speech-related components, while other parts of the framework are being modularized into separate libraries such as NeMo Automodel, NeMo Gym, NeMo RL, and more. This transition aims to make NeMo more modular and developer-friendly.
-
-
-|Repo|Key Functionality & Documentation Link|Training Loop|Training Backends|Infernece Backends|Model Coverage|Container|
-|-|-|-|-|-|-|-|
-|[NeMo Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge)|[Pretraining, LoRA, SFT](https://docs.nvidia.com/nemo/megatron-bridge/latest/)|PyT native loop|Megatron-core|NA|LLM & VLM|NeMo Framework Container
-|[NeMo AutoModel](https://github.com/NVIDIA-NeMo/Automodel)|[Pretraining, LoRA, SFT](https://docs.nvidia.com/nemo/automodel/latest/index.html)|PyT native loop|PyTorch|NA|LLM, VLM, Omni, VFM|NeMo AutoModel Container|
-|[Previous NeMo 2.0 Repo -> will be repurposed to focus on Speech](https://github.com/NVIDIA-NeMo/NeMo)|[Pretraining,SFT](https://docs.nvidia.com/nemo-framework/user-guide/latest/speech_ai/index.html)|PyTorch Lightning Loop|Megatron-core & PyTorch|RIVA|Speech|NA|
-|[NeMo RL](https://github.com/NVIDIA-NeMo/RL)|[SFT, RL](https://docs.nvidia.com/nemo/rl/latest/index.html)|PyT native loop|Megatron-core & PyTorch|vLLM|LLM, VLM|NeMo RL container|
-|[NeMo Gym](https://github.com/NVIDIA-NeMo/Gym)|[RL Environment, integrate with RL Framework](https://docs.nvidia.com/nemo/gym/latest/index.html)|NA|NA|NA|NA|NeMo RL Container (WIP)|
-|[NeMo Aligner (deprecated)](https://github.com/NVIDIA/NeMo-Aligner)|SFT, RL|PyT Lightning Loop|Megatron-core|TRTLLM|LLM|NA
-|[NeMo Curator](https://github.com/NVIDIA-NeMo/Curator)|[Data curation](https://docs.nvidia.com/nemo/curator/latest/)|NA|NA|NA|Agnostic|NeMo Curator Container|
-|[NeMo Evaluator](https://github.com/NVIDIA-NeMo/Evaluator)|[Model evaluation](https://docs.nvidia.com/nemo/evaluator/latest/)|NA|NA||Agnostic|NeMo Framework Container|
-|[NeMo Export-Deploy](https://github.com/NVIDIA-NeMo/Export-Deploy)|[Export to Production](https://docs.nvidia.com/nemo/export-deploy/latest/index.html)|NA|NA|vLLM, TRT, TRTLLM, ONNX|Agnostic|NeMo Framework Container|
-|[NeMo Run](https://github.com/NVIDIA-NeMo/Run)|[Experiment launcher](https://docs.nvidia.com/nemo/run/latest/)|NA|NA|NA|Agnostic|NeMo Framework Container|
-|[NeMo Guardrails](https://github.com/NVIDIA-NeMo/Guardrails)|[Guardrail model response](https://docs.nvidia.com/nemo/guardrails/latest/)|NA|NA|NA||NA|
-|[NeMo Skills](https://github.com/NVIDIA-NeMo/Skills)|[Reference pipeline for SDG & Eval](https://nvidia.github.io/NeMo-Skills/)|NA|NA|NA|Agnostic|NA|
-|[NeMo Emerging Optimizers](https://github.com/NVIDIA-NeMo/Emerging-Optimizers)|[Collection of Optimizers](https://docs.nvidia.com/nemo/emerging-optimizers/0.1.0/index.html)|NA|Agnostic|NA|NA|NA|
-|[NeMo DFM](https://github.com/NVIDIA-NeMo/DFM/tree/main)|[Diffusion foundation model training](https://github.com/NVIDIA-NeMo/DFM/tree/main/docs)|PyT native loop|Megatron-core and PyTorch|NA|Diffusion models|NA|
-|[Nemotron](https://github.com/NVIDIA-NeMo/Nemotron)|Developer asset hub for Nemotron models|NA|NA|NA|Nemotron models|NA|
-|[NeMo Data Designer](https://github.com/NVIDIA-NeMo/DataDesigner)|Synthetic data generation library|NA|NA|NA|NA|NA|
-
-
- Table 1. NeMo Framework Repos
-
-
-
-### Diagram Ilustration of Repos under NeMo Framework (WIP)
-
- 
-
-
- Figure 1. NeMo Framework Repo Overview
-
-
-
-### Some background motivations and historical contexts
-The NeMo GitHub Org and its repo collections are created to address the following problems
-* **Need for composability**: The [Previous NeMo 2.0 version](https://github.com/NVIDIA/NeMo) is monolithic and encompasses too many things, making it hard for users to find what they need. Container size is also an issue. Breaking down the Monolithic repo into a series of functional-focused repos to facilitate code discovery.
-* **Need for customizability**: The [Previous NeMo 2.0 version](https://github.com/NVIDIA/NeMo) uses PyTorch Lighting as the default trainer loop, which provides some out of the box functionality but making it hard to customize. [NeMo Megatron-Bridge](https://github.com/NVIDIA-NeMo/Megatron-Bridge), [NeMo AutoModel](https://github.com/NVIDIA-NeMo/Automodel), and [NeMo RL](https://github.com/NVIDIA-NeMo/RL) have adopted pytorch native custom loop to improve flexibility and ease of use for developers.
-
-
+- [GitHub Discussions](https://github.com/orgs/NVIDIA-NeMo/discussions)
+- [All Repositories](https://github.com/orgs/NVIDIA-NeMo/repositories)
+- [Open Issues](https://github.com/search?q=org%3ANVIDIA-NeMo+is%3Aissue+is%3Aopen&type=issues)
## License
-Apache 2.0 licensed with third-party attributions documented in each repository.
+Review the license terms before using or contributing to NeMo OSS repositories.
+
+Apache 2.0. Third-party attributions are documented in each repository.