NeMo Data Designer: An Extensible Framework for Multimodal Synthetic Data Generation

# NeMo Data Designer: An Extensible Framework for Multimodal Synthetic Data Generation
Source: [https://arxiv.org/html/2609.17699](https://arxiv.org/html/2609.17699)
Nabin MulepatiAndre ManoelEric TramelKirit ThadakaMike KnepperDhruv NathawaniDane CorneilYev MeyerAlex WatsonMaarten Van Segbroeck

###### Abstract

We presentNeMo Data Designer\(NDD\), an open\-source, general\-purpose framework for multimodal synthetic data generation \(SDG\)\. Designed to be intuitive to use, NDD provides a declarative configuration format in which human and/or agent users define each dataset column, with column types spanning text, code, structured outputs, images, embeddings, and statistical samplers that are explicitly configured to steer dataset diversity\. Additional column types and functionality can be introduced using the framework’s flexible plugin system\. NDD’s configuration is an inspectable artifact, supporting workflow sharing and reproducibility\. SDG is an inherently iterative process\. NDD therefore builds a preview\-and\-revision loop into its core workflow, allowing users to generate and inspect a small number of records, refine the specification, and rerun generation at full scale\. At runtime, NDD resolves dependencies, schedules calls to user\-provided model endpoints, and retries failed requests\. We describe NDD’s architecture and programming model and present case studies spanning structured, agentic, multimodal, and domain\-specialized tasks, including datasets used in Nemotron model development and in production enterprise deployments\.

## 1Introduction

Synthetic data generation \(SDG\) has long played an important role in science and technology\. From simulating virtual neutron histories in Monte Carlo experiments\([Richtmyer and von Neumann, 1947](https://arxiv.org/html/2609.17699#bib.bib35)\), to boosting minority classes in imbalanced datasets\([Chawla et al\., 2002](https://arxiv.org/html/2609.17699#bib.bib34)\), to teaching large language models \(LLMs\) to write code from synthetically generated textbooks\([Gunasekar et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib11)\), synthetic data has enabled researchers and engineers to create useful approximations of real\-world data that would otherwise be scarce, costly, sensitive, dangerous, or impossible to obtain, while providing greater control over the scale, composition, and characteristics of the resulting datasets\.

Today, SDG plays a central role across the entire lifecycle of LLMs and the agentic systems they power\. At the pretraining stage, where high\-quality human\-written text is not keeping pace with demand\([Villalobos et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib17)\), synthetically rephrased and augmented web corpora commonly contribute tens of billions to trillions of tokens\([Maini et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib13);[Ben Allal et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib14);[Su et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib15)\)\. Large\-scale studies of this regime show that rephrased text reduces the training tokens needed to reach a given loss when mixed with natural text but not when used alone\([Kang et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib18)\), and that the choice and diversity of the rephrasing prompts strongly affect downstream performance\([Hugging Face, 2026](https://arxiv.org/html/2609.17699#bib.bib16)\)\. Post\-training, in turn, leverages synthetic instructions, preferences, and reasoning traces to teach models new behavior\([Wang et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib6);[Taori et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib7);[Xu et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib8);[Honovich et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib10)\)\. Studies of filtered instruction sets, constrained\-vocabulary stories, and textbook\-quality code show that the composition and quality of such data can matter more than its volume\([Zhou et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib24);[Chen et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib25);[Liu et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib26);[Eldan and Li, 2023](https://arxiv.org/html/2609.17699#bib.bib12);[Gunasekar et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib11)\)\.

Teaching models agentic and multimodal capabilities also heavily relies on SDG\. For multi\-step tasks, such as searching the web\([Nakano et al\., 2021](https://arxiv.org/html/2609.17699#bib.bib27)\), synthetic interaction trajectories are generated at scale\([Qin et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib28);[Kimi Team, 2025](https://arxiv.org/html/2609.17699#bib.bib23)\)\. For visual understanding, textual annotations are generated for images, documents, and videos, and increasingly non\-text modalities themselves are synthesized as well\([Yang et al\., 2025b](https://arxiv.org/html/2609.17699#bib.bib32);[Chen et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib33);[NVIDIA, 2026a](https://arxiv.org/html/2609.17699#bib.bib4)\)\. The Nemotron 3 model reports describe synthetic data pipelines for code, STEM reasoning, structured\-output adherence, SQL, search, tool use, document extraction, and citation behavior\([NVIDIA, 2025b](https://arxiv.org/html/2609.17699#bib.bib3);[NVIDIA, 2026b](https://arxiv.org/html/2609.17699#bib.bib2);[NVIDIA, 2026c](https://arxiv.org/html/2609.17699#bib.bib5)\)\.

The emerging theme is that the usefulness of synthetic data depends on deliberate control over its composition and diversity\([Kang et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib18);[Hugging Face, 2026](https://arxiv.org/html/2609.17699#bib.bib16)\), verification of its correctness and quality\([Feng et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib22);[Chen et al\., 2023](https://arxiv.org/html/2609.17699#bib.bib25)\), and its mixture with and grounding in real\-world data\([Gerstgrasser et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib21)\)\. In practice, SDG pipelines typically accomplish this using bespoke scripts and glue code, which makes them difficult to interpret, share, and reproduce\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_iterative_design_loop_to_artifacts.png)Figure 1:Typical NeMo Data Designer user workflow\.Define dataset columns, generate and evaluate a small preview sample, and iterate until satisfied\. A full run then creates the dataset from the same configuration and saves it along with useful run artifacts\.In this report, we present NeMo Data Designer \(NDD\),111Code available at[https://github\.com/NVIDIA\-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner)\.an open\-source, general\-purpose framework for multimodal SDG\. NDD is designed to be intuitive for both humans and agents\. Datasets are specified in a declarative configuration, which is itself an inspectable, shareable artifact that makes the generation pipeline reproducible\. Built\-in column types include model\-generated text, code, structured outputs, images, and embeddings\. Sampler columns draw from statistical distributions to steer diversity, and validator and judge columns verify the generated values\. New column types can be added through a flexible plugin system, and by combining built\-in and custom columns, most of the generation strategies cited above can be expressed within NDD\.

SDG is an inherently iterative process, since dataset requirements are rarely met on the first generation attempt\. NDD therefore builds iteration into its core design\. We illustrate the typical user workflow in Figure[1](https://arxiv.org/html/2609.17699#S1.F1)\. In the iterative design loop, the user declares the columns of the dataset, generates and reviews a small preview sample, updates the configuration based on their observations, and repeats until satisfied\. The full dataset is then generated at scale from the same configuration\. At runtime, NDD resolves dependencies between columns, schedules calls to user\-provided model endpoints, and retries failed requests\. Synthetic datasets built with NDD have been used in Nemotron model development\([NVIDIA, 2025b](https://arxiv.org/html/2609.17699#bib.bib3);[NVIDIA, 2026b](https://arxiv.org/html/2609.17699#bib.bib2);[NVIDIA, 2026a](https://arxiv.org/html/2609.17699#bib.bib4);[NVIDIA, 2026c](https://arxiv.org/html/2609.17699#bib.bib5)\)and in production enterprise deployments spanning structured, agentic, multimodal, and domain\-specialized tasks \(Section[4](https://arxiv.org/html/2609.17699#S4)\)\.

The key contributions of this work are the following:

- •An open\-source, general\-purpose framework for multimodal SDG\.NDD replaces one\-off pipeline scripts with a declarative configuration that is intuitive for both humans and agents\. The same specification drives preview, iteration, and full\-scale generation, making SDG pipelines easy to interpret, share, and reproduce\.
- •Explicit statistical control over dataset diversity\.Statistical samplers are first\-class column types, with values that follow user\-specified distributions and serve as inputs to generation prompts, giving users direct control over dataset composition and diversity\.
- •Extensibility\.A flexible plugin system allows new column types and functionality to be added without modifying the core framework, making it possible to implement novel generation strategies and explore new modalities in NDD\.
- •Real\-world impact from research and production\.We highlight datasets built with NDD for structured, agentic, multimodal, and domain\-specialized tasks, including data used in Nemotron model development and in enterprise deployments, and summarize their reported downstream results\.

The remainder of this report is organized as follows\. Section[2](https://arxiv.org/html/2609.17699#S2)describes NDD’s architecture\. Section[3](https://arxiv.org/html/2609.17699#S3)presents the pipeline design methodology that recurs across applications\. Section[4](https://arxiv.org/html/2609.17699#S4)describes representative workflows and case studies together with their evaluation results\. Section[5](https://arxiv.org/html/2609.17699#S5)concludes, followed by limitations, broader impact, and availability\.

## 2Architecture

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_architecture_diagram.png)Figure 2:Component architecture and external\-service boundaries\.Solid arrows show the primary configuration and execution path; dashed arrows show plugin extension points\. Model endpoints, MCP tools, and remote validators remain outside NDD’s process boundary\.Behind that user\-facing workflow, NDD keeps dataset design, execution, and external services separate\. Figure[2](https://arxiv.org/html/2609.17699#S2.F2)shows how those pieces fit together and where the system boundary sits\.

### 2\.1Overview

The design API collects declarative definitions for columns and their supporting models, tools, seeds, processors, and profilers\. Installed plugin packages are discovered through the plugin registry; their configuration types participate in compilation, and their implementations enter the same execution paths as built\-in components\. The DAG compiler validates the configuration and resolves it into a directed acyclic graph of columns\. Each column produces one named value, which may appear in the final dataset or serve as input to downstream columns\. Some columns also emit auxiliary side\-effect fields, such as message traces\. Dependencies are inferred from explicit configuration and from Jinja2 references in prompts and expressions, so a column that uses\{\{ schema \}\}or\{\{ persona\.age \}\}automatically waits for those values to exist\. Circular dependencies are rejected when the configuration is compiled, before generation begins\.

The asynchronous runtime schedules ready work from this graph and routes model\-backed tasks through the model runtime, where adaptive request admission regulates calls to external endpoints\. MCP tools and remote validators are invoked across explicit service boundaries\. Materialization writes completed row groups, traces, processor views, and final dataset artifacts without making the external services part of the declarative graph\.

This separation keeps dataset design, model selection, validation policy, and execution machinery independently visible\. The same configuration can therefore describe a dataset without assuming where model weights are hosted or how endpoint capacity is provisioned\.

### 2\.2Design Interface

Dataset designs can be written as declarative YAML or constructed in Python with theDataDesignerConfigBuilder\.preview\(\)andcreate\(\)use default execution settings, while an optionalRunConfiglets users override those settings when needed\. Keeping execution settings outside the column graph allows the same dataset design to be previewed and run at full scale\. Appendix[B\.1](https://arxiv.org/html/2609.17699#A2.SS1)shows the same design in YAML and Python\.

Across both interfaces, fields are declared independently and their dependencies are encoded in data rather than in imperative orchestration code\. References such as`\{\{ audience \}\}`and`\{\{ goal \}\}`identify both prompt substitutions and upstream dependencies, allowing NDD to compile the specification into an executable column graph\. The workflow author declares what each field requires, while the runtime determines when the corresponding work is ready to execute\.

Model\-backed columns follow the same pattern: they name a logical model alias without embedding endpoint, credential, or serving details in the column definition\. Section[2\.4](https://arxiv.org/html/2609.17699#S2.SS4)describes how these aliases resolve into the runtime model stack\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_dependency_aware_generation_and_validation_flow.png)Figure 3:Dependency\-aware generation, quality gating, and materialization\.Seed data and samplers establish record inputs and controlled variation\. Dependent columns construct intermediate fields and model\-generated candidates, while validators and LLM judges separate passing records for transformation and export from rejected records with inspectable failure diagnostics\. Model interactions can also be retained as message and tool\-call traces\.
### 2\.3Columns as Pipeline Building Blocks

Figure[3](https://arxiv.org/html/2609.17699#S2.F3)summarizes the dependency\-aware path from record inputs to materialized outputs\. Seed and sampler columns establish the record population and controlled variation; intermediate and model\-backed columns construct candidate records in stages; and validators and LLM judges apply structural and semantic quality gates\. Passing records can be reshaped by processors for training or evaluation, while rejected records retain failed checks and scores for diagnosis\. Message and tool\-call traces remain separate, inspectable side effects of model generation\. Keeping these stages distinct exposes the pipeline as a sequence of design choices rather than a single overloaded prompt\.

This vocabulary lets a workflow author decompose generation into inspectable stages\. A retrieval pipeline can separate document chunking, artifact extraction, question generation, embedding\-based deduplication, judge scoring, and export\. A text\-to\-SQL pipeline can separate schema sampling, prompt synthesis, SQL generation, dialect validation, and rubric scoring\. Failures are consequently attached to a stage instead of being hidden inside one prompt\. Coverage planning is discussed in Section[3\.2](https://arxiv.org/html/2609.17699#S3.SS2)\.

### 2\.4Models and Providers

Model aliases extend NDD’s declarative programming model to inference\. A model\-backed column names the logical model role it requires rather than an endpoint\. A pipeline can therefore use separate aliases for creative generation, lower\-variance judging, and embeddings, even when some aliases target the same underlying model\. An alias can also be rebound from a hosted API to an enterprise gateway or self\-hosted endpoint without changing prompts or the dependency graph\.

NDD maintains this separation through two configuration objects\. AModelProviderdescribes the serving boundary, including how and where requests are sent\. AModelConfigbinds a workflow\-visible alias to that provider, the underlying model identifier, the operation family \(chat, embedding, or image\), and an inference policy\. The provider therefore answers*where and how a request is sent*, while the model configuration answers*which model role and policy a column uses*\. Model choice and inference policy remain part of the inspectable dataset specification, while credentials and endpoint topology remain provider concerns\.

Listing[6](https://arxiv.org/html/2609.17699#LST6)in Appendix[B](https://arxiv.org/html/2609.17699#A2)gives a complete provider\-and\-alias example, including concrete parameter classes and two aliases that apply different inference policies to the same underlying model\.

Before a run begins, NDD resolves only the aliases referenced by the compiled graph and verifies that their endpoints are available, unless health checking has been disabled\. This catches unavailable model dependencies before generation starts and avoids constructing clients that the workflow never uses\.

At runtime, each alias resolves to a shared model facade for chat completion, embeddings, and image generation\. Provider adapters handle service\-specific protocols and errors, while an admission controller adapts concurrency to endpoint rate limits\. Appendix[C](https://arxiv.org/html/2609.17699#A3)describes this runtime path in detail\.

### 2\.5Async Runtime

The compiled DAG establishes what depends on what; the asynchronous runtime decides when each unit of work can proceed\. In a heterogeneous pipeline, stages rarely finish at the same pace, so a column\-at\-a\-time schedule would leave ready work waiting for the slowest rows\. NDD instead treats the DAG as a live execution plan\. As soon as the required inputs for a row exist, the dependent cell becomes eligible to run\. Ifsummaryandtriviaboth depend ontopic, they can run together, and ananalysisfield can begin for each row as soon as itssummaryis ready\. Independent branches therefore overlap without changing the declarative configuration\.

The runtime processes records in row groups, which bound memory use and provide the unit of checkpointing\. Within a row group, readiness is tracked at the granularity appropriate to each column\. Model\-backed text, embedding, and image columns usually create one task per row, while samplers, seed readers, and vectorized custom columns operate on the group as a whole\. A row\-group task can wait for its upstream inputs without preventing unrelated cell\-level work from advancing\. Columns may also be skipped conditionally for individual rows\. When that happens, only downstream work that depends on the skipped value is affected; unrelated branches continue\.

When many branches become ready together, the scheduler uses a fair queue and enforces global, group, and resource limits\. Work is grouped by provider, model, and request domain, or by local generator, so one wide or rate\-limited branch does not dominate unrelated work\. Model calls pass through the adaptive request\-admission layer detailed in Appendix[C](https://arxiv.org/html/2609.17699#A3)\. Each engine invocation remains a single asynchronous process; partitioning a run across processes belongs to the deployment layer described in Section[2\.7](https://arxiv.org/html/2609.17699#S2.SS7)\.

For long\-running jobs, row groups also make progress durable\. Completed groups can be checkpointed in Parquet and released from memory while later work continues, even when groups finish out of order\. If a run is interrupted or fails, a later invocation can resume from those checkpoints; before continuing, the engine reconstructs progress and checks configuration compatibility\. Retryable failures follow the configured retry policy, while permanent cell failures remove the affected row and its downstream work\. If the non\-retryable error threshold stops a run early, completed rows are preserved and partial rows are discarded\. Optional task traces record dispatch, admission, completion, status, and errors, helping distinguish queueing delay from execution time during diagnosis\.

### 2\.6From Generation to Usable Data

Execution does not end when the runtime produces a value\. NDD must also determine whether that value is usable and preserve enough context to explain how it was produced\. Validation therefore appears directly in the column graph: deterministic validators, remote services, and LLM judges consume generated fields and add pass/fail metadata or scores\. Because these quality gates are graph stages, the scheduler can place them after the data they inspect while keeping validation policy separate from the original generation prompt\. Remote validators cross the external\-service boundary shown in Figure[2](https://arxiv.org/html/2609.17699#S2.F2)\.

Alongside these quality gates, model\-backed columns can call MCP tools when they need outside information or actions\. Each tool result returns to the ongoing model interaction, and the message history can be retained as a trace rather than mixed into the generated field\. After generation and validation, processors reshape batches or completed datasets, and materialization gathers the primary rows, processor\-derived views, traces, checkpoints, and diagnostics into inspectable artifacts\. Together, these stages turn raw generations into data that can be evaluated, audited, and reused\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_deployment_patterns.png)Figure 4:Single\-job and sharded deployment patterns\.Panel \(a\) runs one NDD process against model endpoints and materializes one artifact set\. In panel \(b\), a dataset specification and deployment plan are submitted to an external scheduler, which launches independent jobs with dedicated endpoint deployments and color\-matched output shards\. A downstream assembly step merges those shards into the final dataset\.
### 2\.7Trust and Deployment Boundaries

Two boundaries matter once a pipeline reaches beyond its local data flow: the trust boundary governs what may execute or leave the process, while the execution boundary defines what NDD coordinates directly\.

Model endpoints, remote tools, executable validators, and installed plugins are explicit trust boundaries\. Prompts, seed snippets, intermediate fields, multimodal inputs, tool schemas, and tool observations may leave the local process when sent to a hosted endpoint, gateway, remote tool, or validation service\. Sensitive workflows should use approved endpoints, external secret management, and redaction before egress, and should record provider logging, retention, and geographic\-processing assumptions\. Because these services can change independently of the dataset specification, they can also prevent byte\-for\-byte regeneration\. Section[3\.4](https://arxiv.org/html/2609.17699#S3.SS4)therefore treats reproducibility as an auditable recipe that makes service\-dependent variation visible\.

Executable code and SQL, local callables, remote validators, and plugin packages should run with isolation, scoped credentials, timeouts, network and filesystem limits, and audit logging appropriate to the data\. Tool\-enabled workflows should additionally allowlist MCP providers and tools and review or redact captured traces before training or publication\. Consolidating these controls at the service boundaries keeps them separate from the data\-flow semantics of validators, traces, and processors\.

Within its execution boundary, NDD compiles the dataset configuration, schedules ready work, batches requests, applies retries and validation, adapts request admission, and materializes checkpoints and outputs\. Provisioning, multi\-process partitioning, and distributed orchestration remain external responsibilities\.

For larger runs, a deployment plan assigns deterministic shards and an external scheduler launches one independent NDD process per shard\. Each process maintains its own scheduler, adaptive request\-admission state, checkpoints, traces, and artifact namespace\. The serving topology remains a deployment choice: a job may provision dedicated model endpoints, as shown in Figure[4](https://arxiv.org/html/2609.17699#S2.F4), or multiple jobs may share externally managed endpoints\. Each job writes a separate shard artifact, which an external assembly step merges into the final dataset\. Appendix[D](https://arxiv.org/html/2609.17699#A4)provides capacity\-planning guidance\.

### 2\.8Plugins

Scaling out changes how many independent runtimes execute a configuration\. Plugins extend what that configuration can declare\. Dataset projects often need an internal corpus layout, simulator, domain library, redaction policy, or trainer schema that does not fit a built\-in component\. NDD brings this specialized behavior into the declarative workflow so it remains previewable and auditable\.

The plugin system is the supported extension boundary for this behavior\. It identifies three plugin types: seed readers bring new source systems into the record population, column generators produce values with the same dependency semantics as built\-in columns, and processors transform batches or final datasets into project\-specific inspection, training, or evaluation views\. One\-off custom columns remain useful for prototyping, but a plugin is the better boundary when logic needs a stable configuration schema or reuse across projects\.

A plugin package keeps the same separation of concerns as the core framework\. A user\-facing configuration class declares options, discriminators, dependencies, and metadata; an implementation class performs the narrow runtime behavior; a plugin descriptor connects the two; and a Python entry point exposes that descriptor after installation\. Users can then import the plugin’s configuration classes and continue usingDataDesignerConfigBuilder,preview\(\), andcreate\(\)as before\. Column\-generator plugins become graph nodes with normal dependency semantics, while seed readers and processors use the same declarative workflow and runtime paths\.

Plugins can be distributed as independent Python packages, complete with their own dependencies, documentation, tests, and ownership metadata, through first\-party, internal, or community catalogs\. NDD still owns dependency resolution, scheduling, model\-client integration, validation, traces, and output materialization\. Appendix[B\.8](https://arxiv.org/html/2609.17699#A2.SS8)gives a minimal implementation and usage example\.

## 3Pipeline Design

NDD pipelines differ by domain, but successful workflows tend to follow the same compact recipe: define the record contract, make the desired variation explicit, preview examples before scaling, validate aggressively, and preserve enough provenance to understand both accepted and rejected data\. We use the term*statistical grounding*to indicate that important sources of variation–topic, task type, difficulty, persona, schema shape, tool budget, output format, or document provenance–are represented as seed or sampler fields before the LLM is asked to generate content\. The dataset is therefore shaped by a visible design plan rather than by a single prompt asking for diversity\.

### 3\.1Design Loop

The design loop begins with the record contract: the fields to generate, the downstream trainer or evaluator format, and the labels or traces that must survive export\. The designer then chooses seed sources and coverage axes such as documents, schemas, personas, topics, difficulty levels, document layouts, or tool environments\. These choices are encoded as seed\-dataset and sampler columns so they can be inspected before any large model run\. Generation is decomposed into stages, with model calls reserved for semantic work and deterministic transformations used for parsing, reshaping, or bookkeeping\. Quality gates are specified early, including parsers, validators, dialect or schema checks, LLM judges, distribution checks, and any human review needed for high\-risk outputs\.

preview\(\)is the main checkpoint in this loop\. A small run should expose sampled variables, intermediate fields, rejected examples, and the final record shape\. The preview step answers practical questions before an expensivecreate\(\)run: whether the sampled attributes match the intended distribution, whether prompts receive the right context, whether generated records are repetitive, whether validators reject the intended failures, and whether the output schema matches the downstream consumer\. After a full run, evaluation results and rejected\-record diagnostics feed the next iteration\.

### 3\.2Sampling and Staging

Seed curation determines what generation will amplify\. Seeds may be documents, database schemas, code snippets, agent rollouts, questions, personas, product catalogs, media assets such as images, audio recordings, and videos, or unlabeled domain records\. Before adding generation columns, the designer should decide which seed attributes become labels, which become conditioning context, which are only diagnostics, and which must remain visible after export\. For document\-grounded retrieval, segment identifiers must stay attached to generated questions so positive passages survive filtering and export\. For science reasoning, stratified topic and FDC\-code sampling prevents overrepresented domains from dominating the generated corpus\. For enterprise query workflows, deduplication, privacy scrubbing, and schema normalization often belong before generation begins\([Croitoru et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib1)\)\.

Sampler columns turn a coverage plan into explicit inputs\. Category and subcategory samplers support weighted and hierarchical choices; numerical and SciPy samplers cover common probability distributions; conditional sampling changes parameters based on earlier columns; and person samplers can create Faker\-style profiles or draw from richer Nemotron\-Personas assets\. These operations are cheaper and more predictable than model calls, so they shape dataset composition before generation begins\. Constraints extend this control from marginal to joint conditions: a sampler column can be bounded by an inequality against a scalar or another sampler column, allowing orderings and thresholds to hold by construction rather than through generate\-and\-discard filtering that can skew the accepted distribution\.

Controlled sampling turns a desired coverage plan into executable conditions\. A simple dataset may sample language, style, or difficulty; a more complex one may sample database dialect, schema size, dirty\-data pattern, distractor count, user persona, output format, hop count, evidence window, or tool budget\. Because these variables are ordinary columns, the accepted dataset can be checked against the intended mix after validation\. This also reduces pressure on prompts: instead of asking a model to “be diverse,” the pipeline supplies concrete conditions such as a schema with distractor columns, a strict JSON schema, or a physics passage from an underrepresented topic\.

Most useful records are assembled through several stages\. Retrieval workflows can extract document concepts, generate questions, write answers, deduplicate, and judge grounding\. Text\-to\-SQL workflows can sample a domain and dialect, synthesize schema context, generate a query, then apply syntax and semantic checks\. Tool\-use workflows can construct a seed question, roll out a model through an MCP tool interface, capture the trajectory, and convert successful traces into supervised examples\. Document\-understanding workflows can select pages or page windows, attach rendered images and extracted text as context, generate questions targeted at a reasoning mode, and filter with a vision\-language judge\. Staging keeps each failure local enough to debug and allows stronger or more expensive models to be reserved for the steps that need them\.

### 3\.3Validation and Provenance

Validation converts candidates into usable data\. The right gate depends on the target artifact: parse and schema checks for JSON, YAML, XML, or function\-call data; code and SQL validators for executable or dialect\-constrained outputs; grounding checks for document or tool\-supported answers, including vision\-language judging when the evidence is an image or page; LLM judges for semantic criteria such as relevance, faithfulness, or difficulty; and post\-filter distribution checks when rejection may skew coverage\. Rejection sampling is the common operational pattern: generate more candidates than needed and keep the records that pass the gates; when filtering skews the intended mix, coverage is rebalanced by curating seeds and samplers rather than by a single prompt\. The workflows in this report use this pattern for structured\-output examples, text\-to\-SQL records, and search\-agent trajectories\.

Provenance matters because synthetic data is selected, not merely generated\. During development, intermediate columns, seed identifiers, prompt inputs, model aliases, validation scores, and dropped examples are often as useful as the final record\. For agentic data, full traces are part of the training signal: the sequence of searches, tool results, intermediate turns, and final answer teaches behavior that a standalone answer cannot\. Preserving these traces also makes failures inspectable when a trajectory searches for the wrong entity, ignores evidence, exceeds a tool budget, or reaches the right source but synthesizes the wrong response\.

### 3\.4Export and Reproducibility

The final stage reshapes accepted records for downstream use\. Export and processor stages can render accepted records as chat\-format messages, prompt/completion views, additional parquet shards, evaluator schemas, or inspection views without changing the source generation columns; the Retriever SDG plugin further exports BEIR\-style retrieval artifacts\. The same generated data may therefore support training, evaluation, manual audit, and public release\. Data Designer can publish these artifacts directly to the Hugging Face Hub throughresults\.push\_to\_hub\(\)\. Alongside the dataset and processor\-derived views, the upload includesbuilder\_config\.json, a serialized representation of the dataset’s declarative design state that can be inspected, reloaded, revised, and rerun\.

Reproducibility is not perfect determinism; model endpoints, provider settings, and external tools may change\. The practical target is an auditable recipe: seed identifiers, sampler parameters, prompt templates, model aliases and versions where available, inference settings, validation thresholds, judge rubrics, tool configurations, trace settings, processor outputs, and export schemas\. Keeping rejected examples and intermediate fields is often the fastest way to understand why a dataset changed between iterations\.

## 4Applications and Case Studies

An SDG framework is ultimately tested by the datasets it can produce and validate in practice\. Within the Nemotron program, NDD has been used to create targeted data for specific model capabilities\. NDD has also supported enterprise applications and external collaborations, translating partner\-specific data gaps into validated datasets under domain, privacy, validity, and production constraints\. Together, these applications demonstrate the framework in settings where generated records must survive task\-specific filtering and remain usable for downstream training and evaluation\.

The section progresses from tightly verifiable output and prompt constraints, through executable query generation and multi\-step search trajectories, to multimodal document understanding and statistically grounded personas\. Each case addresses the same questions: What capability or data gap motivated the workflow? What data was required? How did NDD generate and validate it? Where were the accepted records used, and what outcome was observed? Table[1](https://arxiv.org/html/2609.17699#S4.T1)maps each application to the primary NDD strength it demonstrates and the evidence presented\.

Table 1:Representative NDD applications, the framework strength each exposes most directly, the scale of the generated data, and the reported outcomes\.### 4\.1Structured Outputs and Model Usability

#### Programmatic verification\.

Reliable structured outputs allow models and agents to call tools, populate APIs, and pass machine\-readable state between workflow steps\. Training data for this capability pairs diverse instructions and grounding content with record\-specific schemas and responses that conform to them\. NDD samples topics, schema complexity, output format, and prompt arrangement; generates a schema and grounding document; produces multiple candidate responses; and applies format\-specific parsing and schema validation before selecting an accepted rollout\. Schema conformance is therefore checked programmatically rather than inferred from an LLM judge\. Details of the pipeline, released dataset, and results are provided in the structured\-output developer note\.222[https://docs\.nvidia\.com/nemo/datadesigner/dev\-notes/structured\-outputs\-from\-nemotron](https://docs.nvidia.com/nemo/datadesigner/dev-notes/structured-outputs-from-nemotron)

Nemotron 3 Nano used NDD to create approximately 9K JSON\-schema adherence tasks for reinforcement learning, with reward determined by exact schema conformance\([NVIDIA, 2025b](https://arxiv.org/html/2609.17699#bib.bib3)\)\. The corresponding released dataset contains 9,949 verified JSON examples\. Training Nemotron Nano v3 with this data improved accuracy from 80\.2% to 86\.9% on JSONSchemaBench and from 64\.5% to 72\.1% on StructEval\-Text\([Geng et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib30);[Yang et al\., 2025a](https://arxiv.org/html/2609.17699#bib.bib31)\)\. Although the released dataset is JSON\-only, the StructEval\-Text results show improvements across output formats, with TOML and XML remaining the weakest\.

#### Enterprise Case Study: Nemotron 3 Ultra Usability for Perplexity AI

Perplexity’s search engine depends on strict output formats and correct inline citations\. Data Designer turned those product requirements into verifiable training data for Nemotron 3 Ultra\. Building on the structured\-schema capabilities developed for Nemotron 3 Super, the Nemotron 3 Ultra technical report describes a usability curriculum spanning JSON, YAML, XML, TOML, and CSV; document extraction with complex nested fields and distractors; multiple inline citation formats; and free\-form responses that follow detailed formatting instructions\.333[https://research\.nvidia\.com/labs/nemotron/files/NVIDIA\-Nemotron\-3\-Ultra\-Technical\-Report\.pdf](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Ultra-Technical-Report.pdf)NDD generated seed data covering schema adherence, answer formatting, and single\-source, multi\-source, and Perplexity\-style inline citations\. Deterministic verifiers checked schema validity, formatting compliance, reference correctness, and citation coverage\. The resulting environments were incorporated into Ultra’s RLVR and model\-usability teacher training\.

Following training that included these datasets, Nemotron 3 Ultra’s StructEval\-T accuracy improved from 78\.6% to 82\.1%\. This work formed part of the broader NVIDIA\-\-Perplexity collaboration through the Nemotron Coalition, to which Perplexity contributed data and evaluations\.444[https://www\.perplexity\.ai/hub/blog/perplexity\-joins\-the\-nvidia\-nemotron\-coalition](https://www.perplexity.ai/hub/blog/perplexity-joins-the-nvidia-nemotron-coalition)

### 4\.2Text\-to\-SQL

#### Staged structural generation\.

Text\-to\-SQL data trains a model to translate natural\-language requests into executable, dialect\-appropriate queries grounded in realistic database schemas\. Useful records must jointly preserve the request, schema and sample data, SQL dialect, target query, reasoning trace, and validation metadata\. NDD first samples industry, domain, SQL concept, difficulty, dirty\-data pattern, task type, and linguistic style; it then generates the request, schema context, and SQL query in dependent stages\. Schema generation deliberately introduces distractor tables and columns and production\-like irregularities such as dates stored as text, currency symbols, and embedded JSON\. Dialect\-specific validators and five LLM critics score syntax and semantic qualities before filtering\. Details are provided in the developer note and enterprise recipe\.555[https://docs\.nvidia\.com/nemo/datadesigner/dev\-notes/text\-to\-sql\-for\-nemotron\-super](https://docs.nvidia.com/nemo/datadesigner/dev-notes/text-to-sql-for-nemotron-super)666[https://github\.com/NVIDIA\-NeMo/DataDesigner/blob/main/docs/assets/recipes/code\_generation/enterprise\_text\_to\_sql\.py](https://github.com/NVIDIA-NeMo/DataDesigner/blob/main/docs/assets/recipes/code_generation/enterprise_text_to_sql.py)

Figure[5](https://arxiv.org/html/2609.17699#S4.F5)summarizes the pipeline from controlled seeding through dependent generation, validation, and record selection\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_text_to_sql_synthetic_data_pipeline.png)Figure 5:Text\-to\-SQL synthetic\-data pipeline\.A seed taxonomy and controlled samplers establish domain, SQL, and stylistic variation\. Dependent LLM stages generate the request, schema and data, and dialect\-specific query before per\-dialect validation and five LLM judges produce quality signals for record selection\.The workflow generated 300K candidates across PostgreSQL, MySQL, and SQLite and retained 96\.5K after rejecting approximately 68% through its quality waterfall\. Listing[1](https://arxiv.org/html/2609.17699#LST1)illustrates the retained record shape\.

\{

"messages":\[

\{"role":"user","content":"Listpaidinvoices\."\},

\{"role":"assistant","content":"SELECTinvoice\_idFROMinvoicesWHEREstatus='paid';"\}

\],

"sql\_context":"tables:invoices\(invoice\_id,customer\_id,status\)",

"metadata":\{

"sql\_dialect":"PostgreSQL",

"sql\_complexity":"Intermediate",

"is\_valid":true,

"sql\_relevance\_score":4,

"provenance\_columns":\[

"sql\_dialect","sql\_context","sql",

"is\_valid","sql\_relevance\_score"

\]

\}

\}

Listing 1:Illustrative text\-to\-SQL record after filtering and reshaping\.
#### Enterprise case study: CrowdStrike CQL\.

CrowdStrike used NDD to create natural\-language descriptions for analyst\-written CrowdStrike Query Language \(CQL\) queries, enabling reverse labeling from existing structured artifacts\.777[https://www\.crowdstrike\.com/en\-us/blog/crowdstrike\-journey\-in\-customizing\-nvidia\-nemotron\-models/](https://www.crowdstrike.com/en-us/blog/crowdstrike-journey-in-customizing-nvidia-nemotron-models/)Before generation, the queries were deduplicated and sensitive values were scrubbed while preserving their structure\. NDD then generated and quality\-filtered descriptions across analyst personas and complexity levels, and the accepted pairs were used to fine\-tune Llama\-3\.3\-Nemotron\-Super\-49B\-v1\.5\. The resulting model achieved 96% valid\-query accuracy and a 2\.50/5 semantic score, compared with 94% and 2\.35/5 for Claude Sonnet 4\.5\([Croitoru et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib1)\)\. This case shows how privacy\-scrubbed enterprise records can be converted into validated supervised data for a specialized production task\.

### 4\.3Search\-Agent Trajectories

#### Tool\-trace preservation\.

Parametric knowledge is bounded by a model’s training cutoff, while many user queries depend on current information or facts distributed across multiple sources\. Answering these questions requires a search agent to issue queries, inspect results, refine its search strategy, and combine evidence over multiple hops\. Figure[6](https://arxiv.org/html/2609.17699#S4.F6)summarizes the progression from knowledge\-graph seeds to validated, SFT\-ready search trajectories\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_search_agent_synthetic_data_pipeline.png)Figure 6:Search\-agent synthetic\-data pipeline\.Wikidata paths become obfuscated search\-riddle questions, tool\-using rollouts with preserved Thought–Action–Observation traces, and approximately 7K validated SFT records\.Training this behavior requires complete interaction trajectories rather than final answers alone: each record must preserve the reasoning turns, search queries, tool calls, retrieved observations, supporting URLs, termination state, and synthesized response\.

To generate this supervision, NDD begins with four\- to eight\-hop paths through the Wikidata knowledge graph, converts each path into a natural\-language question, and obfuscates intermediate entities so that the answer cannot be recovered by following explicit breadcrumbs\. A rollout agent then attempts to solve the question using live web search through a Tavily MCP tool, while NDD enforces tool allowlists, turn limits, and timeouts and captures the complete Thought\-\-Action\-\-Observation history\. Successful trajectories are normalized into SFT\-ready conversations that preserve the full search process\. The developer note888[https://docs\.nvidia\.com/nemo/datadesigner/dev\-notes/search\-agent](https://docs.nvidia.com/nemo/datadesigner/dev-notes/search-agent)and search\-agent recipe999[https://github\.com/NVIDIA\-NeMo/DataDesigner/blob/main/docs/assets/recipes/mcp\_and\_tooluse/search\_agent\.py](https://github.com/NVIDIA-NeMo/DataDesigner/blob/main/docs/assets/recipes/mcp_and_tooluse/search_agent.py)provide implementations\.

The pipeline converted 50K knowledge\-graph seeds into 24K rollout questions and approximately 7K valid search trajectories, for an end\-to\-end yield of roughly 14%\. The accepted trajectories averaged approximately 12 tool calls, preserved the complete multi\-turn search process, and were incorporated into Nemotron 3 Super supervised fine\-tuning\. This workflow demonstrates how NDD can generate inspectable, long\-horizon tool\-use supervision at a scale that would be costly to annotate manually\.

### 4\.4Long\-Document Vision\-Language Model Understanding

#### Iterative multimodal capability targeting\.

Long\-document visual understanding requires models to interpret text, layout, tables, charts, diagrams, and evidence distributed across many PDF pages\. The dataset must keep document and page identifiers, rendered page images, optical character recognition \(OCR\) text where used, questions, answers, reasoning traces, question\-type labels, and judge decisions attached throughout generation and filtering\.

Rather than relying on one monolithic pipeline, the NDD workflow evolved through four complementary generation streams: OCR\-grounded text QA, classification\-filtered visual QA, general single\-page QA, and grouped\-page QA, with the last stream divided into multi\-page and whole\-document paths\. Evaluation failures determined which document types and reasoning modes were added next, while an independent vision\-language model \(VLM\) judge filtered examples for correctness, question quality, visual grounding, format compliance, and training\-signal strength\. The developer note and nine\-stage recipe suite document these patterns and provide implementation examples\.101010[https://docs\.nvidia\.com/nemo/datadesigner/dev\-notes/vlm\-long\-document\-understanding](https://docs.nvidia.com/nemo/datadesigner/dev-notes/vlm-long-document-understanding)111111[https://github\.com/NVIDIA\-NeMo/DataDesigner/tree/main/docs/assets/recipes/vlm\_long\_doc](https://github.com/NVIDIA-NeMo/DataDesigner/tree/main/docs/assets/recipes/vlm_long_doc)

Figure[7](https://arxiv.org/html/2609.17699#S4.F7)summarizes how the shared document corpus feeds complementary QA\-generation paths and independent quality scoring before selected records enter the broader SFT and RL training blend\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_long_document_vlm_pipeline.png)Figure 7:Long\-document VLM synthetic\-data pipeline\.A shared seed corpus is transformed through Nemotron Parse transcription, visual\-content classification, and grouped\-page preparation into complementary text, single\-page visual, single\-page, multi\-page, and whole\-document QA paths\. A strong independent judge scores quality before selected records contribute to the broader SFT and RL training blend\.The workflow produced approximately 11\.4M visual question\-answer pairs, representing about 45B tokens when questions, answers, reasoning traces, and vision tokens are included\. Across successive data\-generation, supervised fine\-tuning, and reinforcement\-learning interventions, experimental checkpoints improved from 26\.32% to 59\.00% on MMLongBench\-Doc\([Ma et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib29)\)\. The released Nemotron 3 Nano Omni model reports 57\.5% in reasoning\-on mode\([NVIDIA, 2026a](https://arxiv.org/html/2609.17699#bib.bib4)\)\.

The principal systems result is the iterative loop itself: evaluation exposed missing capabilities, NDD generated targeted supervision for them, and the process repeated at increasing levels of document and reasoning complexity\.

### 4\.5Prompt Robustness Through Diverse Instructions

#### Controlled linguistic diversity\.

Prompt\-robustness data reduces sensitivity to superficial changes in instruction wording, tone, placement, and answer format while leaving the underlying task unchanged\. The required artifact is not a new collection of problems, but a validated pool of interchangeable preambles and format instructions that can be applied to existing SFT and RL examples\. Starting from 50 combinations of hand\-written preamble anchors and regex\-paired answer formats, NDD samples six variation axes spanning sentence type, tone, strictness, verbosity, domain, and prompt ordering\. Separate generation columns produce the preamble, format instruction, and assembled prompt, after which judges filter for format compliance, regex alignment, ordering coherence, and linguistic quality\. The complete workflow is available in the prompt\-sensitivity developer note\.121212[https://docs\.nvidia\.com/nemo/datadesigner/dev\-notes/prompt\-sensitivity](https://docs.nvidia.com/nemo/datadesigner/dev-notes/prompt-sensitivity)

Early Nemotron checkpoints showed accuracy swings of as much as 15 percentage points across prompt phrasings for identical questions\. The accepted prompt pool was incorporated into training mixtures using a controlled ratio of canonical and varied instructions; it used 25% canonical and 75% varied prompts\. This recipe was used in Nemotron 3 Nano training, where we observed a roughly 2×\\timesreduction in prompt\-sensitivity variation across GPQA, MMLU\-Pro, competition mathematics, and LiveCodeBench\([NVIDIA, 2025b](https://arxiv.org/html/2609.17699#bib.bib3)\)\.

### 4\.6Nemotron\-Personas

#### Objective and pipeline\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/nemotron_persona_approach.png)Figure 8:Grounded persona generation\.A census\-derived PGM and OCEAN descriptors feed two structured LLM stages\. Each stage may use an independent model alias\.Nemotron\-Personas introduces synthetic personas grounded in demographic, geographic, and personality\-trait statistics to capture the diversity and complexity of a population\. In contrast to earlier persona\-driven data synthesis\([Ge et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib9)\), which scales perspective diversity through web\-derived personas, Nemotron\-Personas grounds regional populations in census and administrative statistics\. This grounding preserves real\-world structure while diversifying synthetic data\. It also reduces skew, enables targeted coverage of lower\-frequency groups, and can help mitigate bias and model collapse\([Shumailov et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib20);[Dohmatob et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib19)\)\. Regional datasets also support multilingual and sovereign AI development\.

Figure[8](https://arxiv.org/html/2609.17699#S4.F8)summarizes the Data Designer pipeline\. For Nemotron\-Personas\-USA, the probabilistic graphical model \(PGM\) encodes selected joint distributions from U\.S\. Census Bureau tables and name\-frequency data\([Meyer and Corneil, 2025](https://arxiv.org/html/2609.17699#bib.bib37)\)\. OCEAN descriptions add a separate psychometric input\. One LLM call creates an intermediate profile and a second produces context\-specific personas\. NDD resolves the column graph and enforces output schemas\. The pipeline follows the compound AI framing\([Zaharia et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib36)\)\.

#### Distributional quality and localization\.

Nemotron\-Personas\-USA contains one million records mirroring complex real\-world distributions and patterns like non\-Gaussian age profiles, life\-stage changes in marital status, and regional variations in education\. Coverage includes approximately 29K ZIP Code Tabulation Areas and more than 560 occupations\. An LLM\-only baseline failed to produce both simple distributions \(e\.g\. age\) and more complex joint disributions \(e\.g\., educational attainment by geographic location and sex\)\([Meyer and Corneil, 2025](https://arxiv.org/html/2609.17699#bib.bib37)\)\.

The public collection, summarized in Figure[9](https://arxiv.org/html/2609.17699#S4.F9), now contains ten regional datasets and 15 language or script editions\([NVIDIA, 2025c](https://arxiv.org/html/2609.17699#bib.bib38)\)\. India spans English and two Hindi scripts\. Belgium provides Dutch, French, German, and English editions\. Locale\-specific fields, regional review, and language\-specialist models preserve distinctions that translation alone cannot supply\([Praveen et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib39);[Delobelle et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib40)\)\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/personas_footprint.png)Figure 9:Nemotron\-Personas global footprint as of August 12, 2026\.Ten live datasets cover regions representing approximately 2\.4B people\. The collection had 410K downloads, five co\-development partners, and more than ten validated applications\.
#### A building block for training and evaluation\.

Nemotron\-Personas provides reusable grounding for both training\-data synthesis and evaluation\. Sampling the persona before generation fixes the user perspective while the downstream task changes\. Nemotron 3 Super uses Nemotron\-Personas\-USA for long\-context aggregation and simulated tool users, while personas from the broader collection diversify formal\-logic scenarios\([NVIDIA, 2026b](https://arxiv.org/html/2609.17699#bib.bib2)\)\. Nemotron 3 Nano extends the pattern to precise instruction following\([NVIDIA, 2025b](https://arxiv.org/html/2609.17699#bib.bib3)\)\. Its training recipe also uses Nemotron\-Personas\-USA for general chat and safety data\([NVIDIA Corporation, 2025](https://arxiv.org/html/2609.17699#bib.bib41)\)\.

Each dataset in the quickly expanding collection is produced in one or more region\-specific languages\. This enables high\-quality multilingual data and sovereign model development\. For example, a 4B\-token Japanese tool\-calling dataset grounded in Nemotron\-Personas\-Japan was used to further post\-train NVIDIA\-Nemotron\-Nano\-9B\-v2\-Japanese, which ranked first among sub\-10B models on Nejumi Leaderboard 4\([NVIDIA Corporation, 2026c](https://arxiv.org/html/2609.17699#bib.bib42)\)\. Nemotron\-Personas\-Japan also enabled NTT DATA to expand 450 legal examples into more than 138K training examples for tsuzumi 2\. Synthetic\-data SFT increased QA accuracy from 15\.3% to 79\.3%\([Jennings et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib43)\)\. Ai2 used Nemotron\-Personas\-USA to generate approximately 220K verified instruction records for each Olmo 3 Think SFT mixture\([Team Olmo et al\., 2025](https://arxiv.org/html/2609.17699#bib.bib44)\), and AMALIA generated European Portuguese instruction\-following and mathematics data\([Simplício et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib45)\)\.

Nemotron\-Personas also defines controlled test populations\. APTO used Japan personas for elderly\-user red teaming, reducing attack success from 6% to 0% across 100 attack prompts after safety fine\-tuning\([NVIDIA Corporation, 2026a](https://arxiv.org/html/2609.17699#bib.bib46)\)\. AMemGym uses a 100K\-persona pool to construct long\-horizon memory evaluations\([Cheng et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib47)\)\. ProactBench uses 50 profiles to create 198 dialogues with 624 proactive\-behavior triggers\([Harfi et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib48)\), while PICon samples seven regional datasets to test persona consistency over 50\-turn conversations\([Kim et al\., 2026](https://arxiv.org/html/2609.17699#bib.bib49)\)\.

#### Open pipeline and customization\.

In addition to datasets, we have open\-sourced the full Nemotron\-Personas pipeline\.The developer note\([Meyer and Corneil, 2026](https://arxiv.org/html/2609.17699#bib.bib50)\)explains the design, and its companion notebook\([NVIDIA Corporation, 2026b](https://arxiv.org/html/2609.17699#bib.bib51)\)provides a runnable recipe for NGC sampling, structured LLM stages, and domain extension\. The recipe is implemented with Data Designer\([NVIDIA, 2025a](https://arxiv.org/html/2609.17699#bib.bib52)\), leaving models, schemas, and validation policies configurable\.

Furthermore, our open\-source SDG\-PGMs\([NVIDIA Corporation, 2026d](https://arxiv.org/html/2609.17699#bib.bib53)\)provides a lightweight path to complete customization\. The Python framework constructs PGMs from aggregate public or proprietary distributions and integrates their samples into Data Designer throughPGMGenerator\.PersonSamplerParamsremains the direct path for reusing released persona assets\.

Nemotron\-Personas demonstrates this abstraction for synthetic people, but SDG\-PGMs is entity\-agnostic\. The same approach can model any entity with structured relationships among its attributes\. Examples include products and transactions, as well as devices and proprietary business objects\.

### 4\.7Broader applicability and SDG Design Principles

The applications above are representative rather than exhaustive\. Beyond these examples, NDD has supported retrieval\-data generation, scientific\-reasoning datasets, and other domain\-specific SDG workflows through task\-specific seed sources, plugins, validators, processors, and export schemas\. Across research and production workflows, NDD has supported the generation of approximately 10 trillion tokens of synthetic data, demonstrating that its programming model scales beyond individual recipes to sustained real\-world use\.

Taken together, these applications show that effective SDG begins by defining the dataset’s intended coverage rather than maximizing generation volume\. Samplers make the desired variation explicit, representative seeds anchor generation in factual or domain\-specific context, and difficulty strata can turn a flat collection into a deliberate curriculum\. The same principle applies to implementation: deterministic decisions should use samplers, expressions, or structured columns, reserving open\-ended LLM generation for fields that require it\.

Generation should then be treated as an iterative selection process\. The text\-to\-SQL workflow illustrates the value of generating broadly and retaining only candidates that pass a quality waterfall, while the structured\-output workflows show that objective requirements are best enforced with parsers, schemas, linters, and custom validators\. LLM judges should be reserved for semantic criteria and, where possible, separated from the generator to reduce shared blind spots\. Previewing a small sample, inspecting both accepted and rejected records, and revising the design before scaling completes the loop\.

## 5Conclusion

We presented NDD, an open\-source framework for designing, generating, and validating multimodal synthetic datasets\. With NDD, both humans and agents can define dataset columns, samplers, dependencies, and quality gates; inspect accepted and rejected records; and turn results into reusable artifacts\. They can start with a small preview, revise the design based on what they observe, and then run it at scale without rewriting the workflow\.

The case studies highlight several ways NDD can be used, but they are not meant to be an exhaustive list\. Its flexible and extensible programming model can be adapted across data types, modalities, validation strategies, and downstream uses\. The workflows described here have contributed to Nemotron model development and enterprise applications\. Their outcomes are necessarily measured differently, but together they support a common conclusion: synthetic\-data generation should be treated as an explicit, inspectable, and reusable data\-design process rather than a collection of isolated prompts\.

This matters because the choices made in a synthetic\-data pipeline influence what a model ultimately learns\. Building the data pipeline is part of building the model\. NDD helps make that level of care practical for both humans and agents\.

## 6Limitations

#### Real data and validation still set the boundary\.

Synthetic data is most useful when there is enough domain knowledge, seed material, or validation logic to constrain generation\. It is weaker when the target phenomenon is new, poorly understood, rapidly changing, or difficult to validate automatically\. A generation pipeline can only optimize for the checks it contains: if a validator misses a semantic error, rewards superficial style, or encodes a biased rubric, the accepted dataset will inherit those weaknesses\. This is sharpest for multimodal data, where visual grounding cannot be checked deterministically and a vision\-language judge is itself an imperfectly calibrated instrument; OCR errors in document pipelines propagate into questions and answers that remain well formed\. Recursive use of untracked model outputs can also erode distributional coverage, while accumulation with real data and verification can mitigate that risk\([Shumailov et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib20);[Gerstgrasser et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib21);[Feng et al\., 2024](https://arxiv.org/html/2609.17699#bib.bib22)\)\. Real data and human review remain essential for discovering unknown failure modes, calibrating LLM judges in high\-stakes settings, and measuring deployment behavior\.

#### Filtering changes the distribution\.

Rejection sampling improves average record quality, but it can also remove difficult, rare, or dialect\-specific cases\. A dataset that is well balanced before validation may become skewed after filtering, and samplers do not guarantee that a synthetic dataset matches a real population or task distribution\. Workflows that depend on distributional fidelity should use representative seed data or external statistics, then audit accepted and rejected records rather than only the final dataset\.

#### Endpoints, cost, and reproducibility are part of the experiment\.

Multi\-stage pipelines often generate more candidates than they retain, which increases compute cost, wall\-clock time, and operational complexity\. The async runtime and adaptive concurrency layer reduce orchestration overhead, but they do not eliminate the cost of model calls or validation\. Because endpoint and tool behavior can also change generated data, reproducibility should follow the auditable\-recipe guidance in Section[3\.4](https://arxiv.org/html/2609.17699#S3.SS4)\.

#### Privacy, leakage, and downstream utility require separate checks\.

Synthetic data can reduce exposure to sensitive records, especially when generated from aggregate statistics or scrubbed seed data, but it should not automatically be treated as private\. Pipelines that condition on real records can leak information if prompts, outputs, traces, or intermediate columns preserve sensitive details\. Generated data can also overlap with benchmark\-like sources, and a dataset can satisfy its schema while failing to improve a model\. Privacy\-sensitive workflows therefore need explicit scrubbing, access controls, access logging, review, benchmark\-overlap checks, and task\-specific downstream evaluation\.

## 7Broader Impact

NDD can reduce some manual annotation effort when seed data and validators are available\. Reusable generation and validation workflows can also reduce the marginal cost of producing new dataset variants, although total savings depend on model\-inference, validation, and human\-review costs\. This can help researchers, startups, and organizations with constrained annotation budgets build datasets for domains where expert labels are scarce\. It can also support fairness and robustness work by making underrepresented cases easier to specify, generate, inspect, and test\.

The same capabilities can be misused\. Synthetic data pipelines can generate persuasive text, phishing\-like examples, biased personas, or task\-specific datasets for harmful automation\. They can also create a false sense of validity if generated records are treated as real observations rather than artifacts produced under a specification\. Responsible use requires provenance tracking, validation, bias assessment, privacy review, access controls for sensitive pipelines, and clear documentation of what the data is and is not intended to represent\.

## 8Availability

NDD is available as open\-source software under the Apache 2\.0 license in its GitHub repository\. This report describes version 0\.9\.0, and the library supports Python 3\.10 and later\. Reference material, installation instructions, tutorials, and recipes are available in the[project documentation](https://nvidia-nemo.github.io/DataDesigner/latest/)\. The library can be used with user\-provided model endpoints, including hosted APIs, centralized LLM gateways, and OpenAI\-compatible self\-hosted servers\.

## 9Acknowledgments

We thank the NVIDIA NeMo team and the broader Data Designer community for building and documenting the framework described in this report\. We also thank the Nemotron teams whose implementations and reports provided the concrete workflows summarized here, including retrieval, text\-to\-SQL, structured\-output, search\-agent, deep\-research, science\-reasoning, long\-document VLM, and persona\-generation efforts\. Finally, we thank the users and partner teams who used Data Designer to create and validate datasets across research and production workflows, helping exercise the framework at scale\.

We are grateful to CrowdStrike for publishing details of the natural\-language\-to\-CQL collaboration, which illustrates the role of synthetic data in a production security workflow\. We also thank Perplexity AI for its collaboration on model\-usability requirements and evaluations that informed the Nemotron 3 Ultra workflow described in Section[4\.1](https://arxiv.org/html/2609.17699#S4.SS1)\.

## References

- Ben Allalet al\.\(2024\)L\. Ben Allal, A\. Lozhkov, and D\. van StrienCosmopedia: how to create large\-scale synthetic data for pre\-training\.Note:[https://huggingface\.co/blog/cosmopedia](https://huggingface.co/blog/cosmopedia)Accessed: 2026\-06\-16Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Chawlaet al\.\(2002\)N\. V\. Chawla, K\. W\. Bowyer, L\. O\. Hall, and W\. P\. KegelmeyerSMOTE: synthetic minority over\-sampling technique\.Journal of Artificial Intelligence Research16,pp\. 321–357\.External Links:[Document](https://dx.doi.org/10.1613/jair.953)Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p1.1)\.
- Chenet al\.\(2023\)L\. Chen, S\. Li, J\. Yan, H\. Wang, K\. Gunaratna,et al\.AlpaGasus: training a better alpaca with fewer data\.Note:arXiv:2307\.08701Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1),[§1](https://arxiv.org/html/2609.17699#S1.p4.1)\.
- Chenet al\.\(2025\)Y\. Chen, F\. Xue, D\. Li, Q\. Hu, L\. Zhu, X\. Li, Y\. Fang, H\. Tang, S\. Yang, Z\. Liu, Y\. He, H\. Yin, P\. Molchanov, J\. Kautz, L\. Fan, Y\. Zhu, Y\. Lu, and S\. HanLongVILA: scaling long\-context visual language models for long videos\.InInternational Conference on Learning Representations,Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1)\.
- Chenget al\.\(2026\)J\. Cheng, D\. Ru, L\. Qiu, Y\. Li, X\. Cao, Y\. Song, and X\. CaiAMemGym: interactive memory benchmarking for assistants in long\-horizon conversations\.InThe Fourteenth International Conference on Learning Representations,Note:arXiv:2603\.01966v1External Links:2603\.01966,[Link](https://openreview.net/forum?id=sfrVLzsmlf)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p3.1)\.
- Croitoruet al\.\(2026\)I\. Croitoru, S\. Chau, R\. Boriceanu, C\. Midler, and D\. CorlatescuCrowdStrike’s journey in customizing NVIDIA Nemotron models for peak accuracy and performance\.Note:[https://www\.crowdstrike\.com/en\-us/blog/crowdstrike\-journey\-in\-customizing\-nvidia\-nemotron\-models/](https://www.crowdstrike.com/en-us/blog/crowdstrike-journey-in-customizing-nvidia-nemotron-models/)Accessed: 2026\-05\-20Cited by:[§3\.2](https://arxiv.org/html/2609.17699#S3.SS2.p1.1),[§4\.2](https://arxiv.org/html/2609.17699#S4.SS2.SSS0.Px2.p1.1)\.
- Delobelleet al\.\(2026\)P\. Delobelle, P\. Langlais, A\. Stasenko, Y\. Detrois, M\. Bendris, B\. Delfino, S\. Prayaga, A\. Sharabiani, B\. Sadeghi, W\. Jennings, K\. Praveen, M\. Van Segbroeck, D\. Corneil, and Y\. MeyerNemotron\-Personas\-Belgium: synthetic personas aligned to real\-world distributions for belgium\.Note:[https://huggingface\.co/datasets/nvidia/Nemotron\-Personas\-Belgium](https://huggingface.co/datasets/nvidia/Nemotron-Personas-Belgium)Hugging Face dataset; version 1\.0; released June 16, 2026Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px2.p2.1)\.
- Dohmatobet al\.\(2024\)E\. Dohmatob, Y\. Feng, A\. Subramonian, and J\. KempeStrong model collapse\.Note:arXiv:2410\.04840Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px1.p1.1)\.
- Eldan and Li \(2023\)R\. Eldan and Y\. LiTinyStories: how small can language models be and still speak coherent English?\.Note:arXiv:2305\.07759Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Fenget al\.\(2024\)Y\. Feng, E\. Dohmatob, P\. Yang, F\. Charton, and J\. KempeBeyond model collapse: scaling up with synthesized data requires verification\.Note:arXiv:2406\.07515Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p4.1),[§6](https://arxiv.org/html/2609.17699#S6.SS0.SSS0.Px1.p1.1)\.
- Geet al\.\(2024\)T\. Ge, X\. Chan, X\. Wang, D\. Yu, H\. Mi, and D\. YuScaling synthetic data creation with 1,000,000,000 personas\.Note:arXiv:2406\.20094Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px1.p1.1)\.
- Genget al\.\(2025\)S\. Geng, H\. Cooper, M\. Moskal,et al\.Generating structured outputs from language models: benchmark and studies\.Note:arXiv:2501\.10868Cited by:[§4\.1](https://arxiv.org/html/2609.17699#S4.SS1.SSS0.Px1.p2.1)\.
- Gerstgrasseret al\.\(2024\)M\. Gerstgrasser, R\. Schaeffer, A\. Dey, R\. Rafailov, H\. Sleight, J\. Hughes, T\. Korbak, R\. Agrawal, D\. Pai, A\. Gromov, D\. A\. Roberts, D\. Yang, D\. L\. Donoho, and S\. KoyejoIs model collapse inevitable? breaking the curse of recursion by accumulating real and synthetic data\.Note:arXiv:2404\.01413Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p4.1),[§6](https://arxiv.org/html/2609.17699#S6.SS0.SSS0.Px1.p1.1)\.
- Gunasekaret al\.\(2023\)S\. Gunasekar, Y\. Zhang, J\. Aneja, C\. C\. T\. Mendes,et al\.Textbooks are all you need\.Note:arXiv:2306\.11644Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p1.1),[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Harfiet al\.\(2026\)S\. Harfi, A\. Salimi, D\. Shen, and A\. SmolaProactBench: beyond what The user asked for\.Note:arXiv:2605\.09228v1External Links:2605\.09228,[Document](https://dx.doi.org/10.48550/arXiv.2605.09228),[Link](https://arxiv.org/abs/2605.09228)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p3.1)\.
- Honovichet al\.\(2023\)O\. Honovich, T\. Scialom, O\. Levy, and T\. SchickUnnatural instructions: tuning language models with \(almost\) no human labor\.InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics,pp\. 14409–14428\.Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Hugging Face \(2026\)Hugging FaceThe synthetic data playbook: generating trillions of the finest tokens\.Note:[https://huggingface\.co/spaces/HuggingFaceFW/finephrase](https://huggingface.co/spaces/HuggingFaceFW/finephrase)Accessed: 2026\-06\-16Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1),[§1](https://arxiv.org/html/2609.17699#S1.p4.1)\.
- Jenningset al\.\(2026\)W\. Jennings, A\. Fujita, M\. Ogushi, Y\. Meyer, Y\. Suhara, K\. Yamamoto, D\. Corneil, and V\. GongFrom scarcity to scale: how synthetic personas can bootstrap japanese AI development\.Note:[https://huggingface\.co/blog/nvidia/nemotron\-personas\-japan\-nttdata](https://huggingface.co/blog/nvidia/nemotron-personas-japan-nttdata)Published February 19, 2026Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p2.1)\.
- Kanget al\.\(2025\)F\. Kang, N\. Ardalani, M\. Kuchnik, Y\. Emad, M\. Elhoushi, S\. Sengupta, S\. Li, R\. Raghavendra, R\. Jia, and C\. WuDemystifying synthetic data in LLM pre\-training: a systematic study of scaling laws, benefits, and pitfalls\.Note:arXiv:2510\.01631Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1),[§1](https://arxiv.org/html/2609.17699#S1.p4.1)\.
- Kimet al\.\(2026\)M\. Kim, S\. Im, J\. Choi, J\. Lee, C\. Shim, H\. Hong, and E\. ChoiPICon: a multi\-turn interrogation framework for evaluating persona agent consistency\.Note:arXiv:2603\.25620v4External Links:2603\.25620,[Document](https://dx.doi.org/10.48550/arXiv.2603.25620),[Link](https://arxiv.org/abs/2603.25620)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p3.1)\.
- Kimi Team \(2025\)Kimi TeamKimi K2: open agentic intelligence\.Note:arXiv:2507\.20534Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1)\.
- Liuet al\.\(2024\)W\. Liu, W\. Zeng, K\. He, Y\. Jiang, and J\. HeWhat makes good data for alignment? a comprehensive study of automatic data selection in instruction tuning\.Note:arXiv:2312\.15685Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Maet al\.\(2024\)Y\. Ma, Y\. Zang, L\. Chen, M\. Chen, Y\. Jiao, X\. Li, X\. Lu, Z\. Liu, Y\. Ma, X\. Dong, P\. Zhang, L\. Pan, Y\. Jiang, J\. Wang, Y\. Cao, and A\. SunMMLongBench\-Doc: benchmarking long\-context document understanding with visualizations\.InAdvances in Neural Information Processing Systems,Cited by:[§4\.4](https://arxiv.org/html/2609.17699#S4.SS4.SSS0.Px1.p4.1)\.
- Mainiet al\.\(2024\)P\. Maini, S\. Seto, H\. Bai, D\. Grangier, Y\. Zhang, and N\. JaitlyRephrasing the web: a recipe for compute and data\-efficient language modeling\.Note:arXiv:2401\.16380Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Meyer and Corneil \(2025\)Y\. Meyer and D\. CorneilNemotron\-Personas\-USA: synthetic personas aligned to real\-world distributions\.Note:[https://huggingface\.co/datasets/nvidia/Nemotron\-Personas\-USA](https://huggingface.co/datasets/nvidia/Nemotron-Personas-USA)Hugging Face dataset; initial release June 9, 2025; data version 1\.1 released October 28, 2025Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px1.p2.1),[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px2.p1.1)\.
- Meyer and Corneil \(2026\)Y\. Meyer and D\. CorneilDesigning Nemotron\-Personas: multi\-locale synthetic personas powering nemotron training\.Note:[https://docs\.nvidia\.com/nemo/datadesigner/v0\.6\.1/dev\-notes/designing\-nemotron\-personas](https://docs.nvidia.com/nemo/datadesigner/v0.6.1/dev-notes/designing-nemotron-personas)NVIDIA NeMo Data Designer developer note; published June 1, 2026; documentation version 0\.6\.1Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px4.p1.1)\.
- Nakanoet al\.\(2021\)R\. Nakano, J\. Hilton, S\. Balaji, J\. Wu, L\. Ouyang, C\. Kim, C\. Hesse, S\. Jain, V\. Kosaraju, W\. Saunders, X\. Jiang, K\. Cobbe, T\. Eloundou, G\. Krueger, K\. Button, M\. Knight, B\. Chess, and J\. SchulmanWebGPT: browser\-assisted question\-answering with human feedback\.Note:arXiv:2112\.09332Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1)\.
- NVIDIA Corporation \(2025\)NVIDIA CorporationNVIDIA\-Nemotron\-3\-Nano\-30B\-A3B\-BF16\.Note:[https://huggingface\.co/nvidia/NVIDIA\-Nemotron\-3\-Nano\-30B\-A3B\-BF16](https://huggingface.co/nvidia/NVIDIA-Nemotron-3-Nano-30B-A3B-BF16)Model card; model version 1\.0; released December 15, 2025Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p1.1)\.
- NVIDIA Corporation \(2026a\)NVIDIA CorporationAPTO achieves faster development and higher quality for “AI data”\.Note:[https://www\.nvidia\.com/ja\-jp/case\-studies/apto\-improves\-ai\-data\-quality/](https://www.nvidia.com/ja-jp/case-studies/apto-improves-ai-data-quality/)Customer case study; English translation of the Japanese title; no publication date displayed; available by March 4, 2026; accessed September 3, 2026Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p3.1)\.
- NVIDIA Corporation \(2026b\)NVIDIA CorporationData designer tutorial: reproducing & customizing Nemotron\-Personas\.Note:[https://github\.com/NVIDIA\-NeMo/DataDesigner/blob/v0\.6\.1/docs/colab\_notebooks/7\-nemotron\-personas\.ipynb](https://github.com/NVIDIA-NeMo/DataDesigner/blob/v0.6.1/docs/colab_notebooks/7-nemotron-personas.ipynb)Jupyter tutorial notebook; first published June 1, 2026; Data Designer v0\.6\.1 snapshotCited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px4.p1.1)\.
- NVIDIA Corporation \(2026c\)NVIDIA CorporationNVIDIA\-Nemotron\-Nano\-9B\-v2\-Japanese\.Note:[https://huggingface\.co/nvidia/NVIDIA\-Nemotron\-Nano\-9B\-v2\-Japanese](https://huggingface.co/nvidia/NVIDIA-Nemotron-Nano-9B-v2-Japanese)Model card; model version 1\.0; released February 17, 2026; further trained by NVIDIA JapanCited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p2.1)\.
- NVIDIA Corporation \(2026d\)NVIDIA CorporationSDG\-PGMs: probabilistic graphical models for synthetic data generation\.Note:[https://github\.com/NVIDIA\-NeMo/SDG\-PGMs](https://github.com/NVIDIA-NeMo/SDG-PGMs)Open\-source software; GitHub release v1\.0\.2 published May 29, 2026; package metadata in that tag declares version 0\.1\.0Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px4.p2.1)\.
- NVIDIA \(2025a\)NVIDIANeMo Data Designer: a framework for generating synthetic data from scratch or based on your own seed data\.Note:[https://github\.com/NVIDIA\-NeMo/DataDesigner](https://github.com/NVIDIA-NeMo/DataDesigner)GitHub repository; open\-source softwareCited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px4.p1.1)\.
- NVIDIA \(2025b\)NVIDIANemotron 3 Nano: open, efficient mixture\-of\-experts hybrid Mamba\-Transformer model for agentic reasoning\.Note:[https://research\.nvidia\.com/labs/nemotron/files/NVIDIA\-Nemotron\-3\-Nano\-Technical\-Report\.pdf](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Nano-Technical-Report.pdf)Technical report\. Accessed: 2026\-05\-20Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1),[§1](https://arxiv.org/html/2609.17699#S1.p6.1),[§4\.1](https://arxiv.org/html/2609.17699#S4.SS1.SSS0.Px1.p2.1),[§4\.5](https://arxiv.org/html/2609.17699#S4.SS5.SSS0.Px1.p2.1),[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p1.1)\.
- NVIDIA \(2025c\)NVIDIANemotron\-Personas\.Note:[https://huggingface\.co/collections/nvidia/nemotron\-personas](https://huggingface.co/collections/nvidia/nemotron-personas)Hugging Face collection; created September 25, 2025; made public October 24, 2025; accessed September 3, 2026Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px2.p2.1)\.
- NVIDIA \(2026a\)NVIDIANemotron 3 Nano Omni: efficient and open multimodal intelligence\.Note:arXiv:2604\.24954Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1),[§1](https://arxiv.org/html/2609.17699#S1.p6.1),[§4\.4](https://arxiv.org/html/2609.17699#S4.SS4.SSS0.Px1.p4.1)\.
- NVIDIA \(2026b\)NVIDIANemotron 3 Super: open, efficient mixture\-of\-experts hybrid Mamba\-Transformer model for agentic reasoning\.Note:[https://research\.nvidia\.com/labs/nemotron/files/NVIDIA\-Nemotron\-3\-Super\-Technical\-Report\.pdf](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Super-Technical-Report.pdf)Technical report\. Accessed: 2026\-05\-20Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1),[§1](https://arxiv.org/html/2609.17699#S1.p6.1),[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p1.1)\.
- NVIDIA \(2026c\)NVIDIANemotron 3 Ultra: open, efficient mixture\-of\-experts hybrid Mamba\-Transformer model for agentic reasoning\.Note:[https://research\.nvidia\.com/labs/nemotron/files/NVIDIA\-Nemotron\-3\-Ultra\-Technical\-Report\.pdf](https://research.nvidia.com/labs/nemotron/files/NVIDIA-Nemotron-3-Ultra-Technical-Report.pdf)Technical report\. Accessed: 2026\-06\-09Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1),[§1](https://arxiv.org/html/2609.17699#S1.p6.1)\.
- Praveenet al\.\(2025\)K\. Praveen, U\. Vaidya, E\. Acharya, L\. Ramaswamy, D\. Nathawani, D\. Corneil, and Y\. MeyerNemotron\-Personas\-India: synthetic personas aligned to real\-world distributions for india\.Note:[https://huggingface\.co/datasets/nvidia/Nemotron\-Personas\-India](https://huggingface.co/datasets/nvidia/Nemotron-Personas-India)Hugging Face dataset; version 1\.0; released October 13, 2025Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px2.p2.1)\.
- Qinet al\.\(2024\)Y\. Qin, S\. Liang, Y\. Ye,et al\.ToolLLM: facilitating large language models to master 16000\+ real\-world APIs\.InInternational Conference on Learning Representations,Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1)\.
- Richtmyer and von Neumann \(1947\)R\. D\. Richtmyer and J\. von NeumannStatistical methods in neutron diffusion\.Technical reportTechnical ReportLAMS\-551,Los Alamos Scientific Laboratory\.Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p1.1)\.
- Shumailovet al\.\(2024\)I\. Shumailov, Z\. Shumaylov, Y\. Zhao, N\. Papernot, R\. Anderson, and Y\. GalAI models collapse when trained on recursively generated data\.Nature631,pp\. 755–759\.External Links:[Document](https://dx.doi.org/10.1038/s41586-024-07566-y)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px1.p1.1),[§6](https://arxiv.org/html/2609.17699#S6.SS0.SSS0.Px1.p1.1)\.
- Simplícioet al\.\(2026\)A\. Simplício, G\. Vinagre, M\. M\. Ramos, D\. Tavares, R\. Ferreira, G\. Attanasio, D\. M\. Alves, I\. Calvo, I\. Vieira, R\. Guerra, J\. Furtado, B\. Canaverde, I\. Paulo, V\. Ramos, D\. Glória\-Silva, M\. Faria, M\. Treviso, D\. Gomes, P\. Gomes, D\. Semedo, A\. Martins, and J\. MagalhãesAMALIA: a fully open large language model for European Portuguese\.InProceedings of the 17th International Conference on Computational Processing of Portuguese \(PROPOR 2026\) \- Vol\. 1,M\. Souza, I\. de\-Dios\-Flores, D\. Santos, L\. Freitas, J\. W\. d\. C\. Souza, and E\. Ribeiro \(Eds\.\),Salvador, Brazil,pp\. 380–391\.External Links:ISBN 979\-8\-89176\-387\-6,[Link](https://aclanthology.org/2026.propor-1.38/)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p2.1)\.
- Suet al\.\(2025\)D\. Su, K\. Kong, Y\. Lin, J\. Jennings, B\. Norick, M\. Kliegl, M\. Patwary, M\. Shoeybi, and B\. CatanzaroNemotron\-CC: transforming common crawl into a refined long\-horizon pretraining dataset\.Note:arXiv:2412\.02595Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Taoriet al\.\(2023\)R\. Taori, I\. Gulrajani, T\. Zhang, Y\. Dubois, X\. Li, C\. Guestrin, P\. Liang, and T\. B\. HashimotoAlpaca: a strong, replicable instruction\-following model\.Note:[https://crfm\.stanford\.edu/2023/03/13/alpaca\.html](https://crfm.stanford.edu/2023/03/13/alpaca.html)Accessed: 2026\-05\-20Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Team Olmoet al\.\(2025\)Team Olmo, A\. Ettinger, A\. Bertsch, B\. Kuehl, D\. Graham, D\. Heineman, D\. Groeneveld, F\. Brahman, F\. Timbers, H\. Ivison, J\. Morrison, J\. Poznanski, K\. Lo, L\. Soldaini, M\. Jordan, M\. Chen, M\. Noukhovitch, N\. Lambert, P\. Walsh, P\. Dasigi, R\. Berry, S\. Malik, S\. Shah, S\. Geng, S\. Arora, S\. Gupta, T\. Anderson, T\. Xiao, T\. Murray, T\. Romero, V\. Graf, A\. Asai, A\. Bhagia, A\. Wettig, A\. Liu, A\. Rangapur, C\. Anastasiades, C\. Huang, D\. Schwenk, H\. Trivedi, I\. Magnusson, J\. Lochner, J\. Liu, L\. J\. V\. Miranda, M\. Sap, M\. Morgan, M\. Schmitz, M\. Guerquin, M\. Wilson, R\. Huff, R\. Le Bras, R\. Xin, R\. Shao, S\. Skjonsberg, S\. Z\. Shen, S\. S\. Li, T\. Wilde, V\. Pyatkin, W\. Merrill, Y\. Chang, Y\. Gu, Z\. Zeng, A\. Sabharwal, L\. Zettlemoyer, P\. W\. Koh, A\. Farhadi, N\. A\. Smith, and H\. HajishirziOlmo 3\.Note:arXiv:2512\.13961v2External Links:2512\.13961,[Document](https://dx.doi.org/10.48550/arXiv.2512.13961),[Link](https://arxiv.org/abs/2512.13961)Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px3.p2.1)\.
- Villaloboset al\.\(2024\)P\. Villalobos, A\. Ho, J\. Sevilla, T\. Besiroglu, L\. Heim, and M\. HobbhahnWill we run out of data? limits of LLM scaling based on human\-generated data\.Note:arXiv:2211\.04325Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Wanget al\.\(2023\)Y\. Wang, Y\. Kordi, S\. Mishra, A\. Liu, N\. A\. Smith, D\. Khashabi, and H\. HajishirziSelf\-instruct: aligning language models with self\-generated instructions\.InProceedings of the 61st Annual Meeting of the Association for Computational Linguistics,pp\. 13484–13508\.Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Xuet al\.\(2023\)C\. Xu, Q\. Sun, K\. Zheng, X\. Geng, P\. Zhao, J\. Feng, C\. Tao, and D\. JiangWizardLM: empowering large language models to follow complex instructions\.Note:arXiv:2304\.12244Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.
- Yanget al\.\(2025a\)J\. Yang, D\. Jiang, L\. He,et al\.StructEval: benchmarking LLMs’ capabilities to generate structural outputs\.Note:arXiv:2505\.20139Cited by:[§4\.1](https://arxiv.org/html/2609.17699#S4.SS1.SSS0.Px1.p2.1)\.
- Yanget al\.\(2025b\)Y\. Yang, A\. Patel, M\. Deitke, T\. Gupta, L\. Weihs, A\. Head, M\. Yatskar, C\. Callison\-Burch, R\. Krishna, A\. Kembhavi, and C\. ClarkScaling text\-rich image understanding via code\-guided synthetic multimodal data generation\.InProceedings of the 63rd Annual Meeting of the Association for Computational Linguistics,pp\. 17486–17505\.External Links:[Document](https://dx.doi.org/10.18653/v1/2025.acl-long.855)Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p3.1)\.
- Zahariaet al\.\(2024\)M\. Zaharia, O\. Khattab, L\. Chen, J\. Q\. Davis, H\. Miller, C\. Potts, J\. Zou, M\. Carbin, J\. Frankle, N\. Rao, and A\. GhodsiThe shift from models to compound AI systems\.Note:[https://bair\.berkeley\.edu/blog/2024/02/18/compound\-ai\-systems/](https://bair.berkeley.edu/blog/2024/02/18/compound-ai-systems/)The Berkeley Artificial Intelligence Research Blog; published February 18, 2024Cited by:[§4\.6](https://arxiv.org/html/2609.17699#S4.SS6.SSS0.Px1.p2.1)\.
- Zhouet al\.\(2023\)C\. Zhou, P\. Liu, P\. Xu, S\. Iyer, J\. Sun, Y\. Mao, X\. Ma, A\. Efrat, P\. Yu, L\. Yu, S\. Zhang, G\. Ghosh, M\. Lewis, L\. Zettlemoyer, and O\. LevyLIMA: less is more for alignment\.InAdvances in Neural Information Processing Systems,Vol\.36\.Cited by:[§1](https://arxiv.org/html/2609.17699#S1.p2.1)\.

## Appendix AInstallation Examples

This appendix collects the small setup and first\-run material that is useful for readers who want to reproduce the programming model without interrupting the main systems narrative\. NDD is a Python package that calls user\-provided model endpoints and provides default provider configuration for common hosted services\.

pipinstalldata\-designer

exportNVIDIA\_API\_KEY="your\-api\-key\-here"

exportOPENAI\_API\_KEY="your\-openai\-api\-key\-here"

exportOPENROUTER\_API\_KEY="your\-openrouter\-api\-key\-here"

data\-designerconfiglist

Listing 2:Installation and provider\-configuration checks\. API\-key values are placeholders\.The smallest useful workflow is to declare a builder, add columns, preview a few records, and then revise the design before a fullcreate\(\)run\. Listing[3](https://arxiv.org/html/2609.17699#LST3)shows a greeting example and is intentionally limited to the preview checkpoint; Appendix[B\.1](https://arxiv.org/html/2609.17699#A2.SS1)compares the same builder pattern with a compact YAML declaration\.

importdata\_designer\.configasdd

fromdata\_designer\.interfaceimportDataDesigner

data\_designer=DataDesigner\(\)

config\_builder=dd\.DataDesignerConfigBuilder\(\)

config\_builder\.add\_column\(

dd\.SamplerColumnConfig\(

name="language",

sampler\_type=dd\.SamplerType\.CATEGORY,

params=dd\.CategorySamplerParams\(

values=\["English","Spanish","French","German","Italian"\],

\),

\)

\)

config\_builder\.add\_column\(

dd\.LLMTextColumnConfig\(

name="greeting",

model\_alias="nvidia\-text",

prompt="Writeacasualandformalgreetingin\{\{language\}\}\.",

\)

\)

results=data\_designer\.preview\(config\_builder\)

results\.display\_sample\_record\(\)

Listing 3:Minimal preview workflow\. The prompt references the sampledlanguagefield with Jinja syntax, so the runtime can infer the column dependency\.The setup should be read as an interface example rather than a complete experimental protocol\. For the reproducibility record required for larger runs, see Section[3\.4](https://arxiv.org/html/2609.17699#S3.SS4)\.

## Appendix BConfiguration Examples

The examples below show declarative and builder representations alongside short configuration excerpts for common NDD patterns: sampler\-controlled generation, structured outputs, multimodal context, image generation, validation columns, processor\-based export views, and MCP trace capture\. They are not intended to be a complete recipe for any one public case study\. String placeholders such as"my\-model\-alias","my\-image\-model\-alias","my\-multimodal\-model\-alias", and"demo\-mcp"denote user\-configured aliases rather than built\-in API names\. The appendix provides a stable destination for code and configuration details that would otherwise crowd the main body\.

### B\.1Declarative Configuration and Builder Equivalence

The same dataset design can be represented as a compact declarative schema or constructed through the Python builder\. Listings[4](https://arxiv.org/html/2609.17699#LST4)and[5](https://arxiv.org/html/2609.17699#LST5)compare the two forms; runtime calls such aspreview\(\)andcreate\(\)remain outside the dataset specification in both cases\.

columns:

\-name:audience

column\_type:sampler

sampler\_type:category

params:

values:\[developer,analyst,student\]

\-name:goal

column\_type:sampler

sampler\_type:category

params:

values:\[definition,comparison\]

\-name:answer

column\_type:llm\-text

model\_alias:nvidia\-text

prompt:\>

Writea\{\{goal\}\}answerfora

\{\{audience\}\}aboutdependency\-aware

syntheticdatageneration\.

processors:

\-name:chat\_view

processor\_type:schema\_transform

template:

messages:

\-role:user

content:"Explain\{\{goal\}\}\."

\-role:assistant

content:"\{\{answer\}\}"

Listing 4:Declarative YAML dataset configuration\.importdata\_designer\.configasdd

builder=dd\.DataDesignerConfigBuilder\(\)

builder\.add\_column\(dd\.SamplerColumnConfig\(

name="audience",

sampler\_type=dd\.SamplerType\.CATEGORY,

params=dd\.CategorySamplerParams\(

values=\["developer","analyst","student"\],

\),

\)\)

builder\.add\_column\(dd\.SamplerColumnConfig\(

name="goal",

sampler\_type=dd\.SamplerType\.CATEGORY,

params=dd\.CategorySamplerParams\(

values=\["definition","comparison"\],

\),

\)\)

builder\.add\_column\(dd\.LLMTextColumnConfig\(

name="answer",

model\_alias="nvidia\-text",

prompt=\(

"Writea\{\{goal\}\}answerfora"

"\{\{audience\}\}aboutdependency\-aware"

"syntheticdatageneration\."

\),

\)\)

builder\.add\_processor\(dd\.SchemaTransformProcessorConfig\(

name="chat\_view",

template=\{"messages":\[

\{"role":"user","content":"Explain\{\{goal\}\}\."\},

\{"role":"assistant","content":"\{\{answer\}\}"\},

\]\},

\)\)

Listing 5:Equivalent Python builder configuration\.
### B\.2Model Providers and Aliases

AModelProviderdefines endpoint connectivity, whileModelConfigobjects assign inference policies to logical aliases used by columns\. Listing[6](https://arxiv.org/html/2609.17699#LST6)configures two aliases with different temperatures for the same underlying model; the column definitions depend only on those aliases\.

importdata\_designer\.configasdd

fromdata\_designer\.interfaceimportDataDesigner

provider=dd\.ModelProvider\(

name="enterprise\-gateway",

endpoint="https://llm\.example\.com/v1",

api\_key="LLM\_API\_KEY",

\)

generator=dd\.ModelConfig\(

alias="generator",

model="organization/model",

provider=provider\.name,

inference\_parameters=dd\.ChatCompletionInferenceParams\(

temperature=0\.9,

max\_parallel\_requests=32,

\),

\)

critic=dd\.ModelConfig\(

alias="critic",

model="organization/model",

provider=provider\.name,

inference\_parameters=dd\.ChatCompletionInferenceParams\(

temperature=0\.1,

max\_parallel\_requests=32,

\),

\)

data\_designer=DataDesigner\(model\_providers=\[provider\]\)

config\_builder=dd\.DataDesignerConfigBuilder\(

model\_configs=\[generator,critic\]

\)

config\_builder\.add\_column\(dd\.LLMTextColumnConfig\(

name="answer",

model\_alias="generator",

prompt="Explaindependency\-awareSDG\.",

\)\)

config\_builder\.add\_column\(dd\.LLMTextColumnConfig\(

name="critique",

model\_alias="critic",

prompt="Critique:\{\{answer\}\}",

\)\)

Listing 6:Provider configuration and two model aliases with distinct inference policies\.
### B\.3Structured Output

LLMStructuredColumnConfigsupports either Pydantic models or JSON schemas as the output contract\. Listing[7](https://arxiv.org/html/2609.17699#LST7)shows a compact Pydantic\-based excerpt\.

frompydanticimportBaseModel,Field

importdata\_designer\.configasdd

classProduct\(BaseModel\):

name:str

description:str

price:float=Field\(ge=10,le=1000\)

config\_builder\.add\_column\(dd\.SamplerColumnConfig\(

name="product\_category",

sampler\_type=dd\.SamplerType\.CATEGORY,

params=dd\.CategorySamplerParams\(

values=\["Electronics","Clothing","HomeOffice"\],

\),

\)\)

config\_builder\.add\_column\(dd\.LLMStructuredColumnConfig\(

name="product",

prompt="Createa\{\{product\_category\}\}product\.",

output\_format=Product,

model\_alias="my\-model\-alias",

\)\)

Listing 7:Sampler and structured\-output excerpt\. The shown model alias is a user\-configured placeholder\.
### B\.4Multimodal Context and Image Generation

ImageColumnConfiggenerates an image through a configured image\-model alias, whilemulti\_modal\_contextattaches media from existing columns to a model request\. Listing[8](https://arxiv.org/html/2609.17699#LST8)combines the two patterns: sampler values control an image prompt, and a downstream vision\-language column receives the generated image throughImageContext\. The context declaration also creates a dependency onscene\_image, so caption generation waits for the image column without requiring imperative orchestration\. The selected aliases must refer to endpoints that support image generation and image input, respectively\.

builder\.add\_column\(dd\.SamplerColumnConfig\(

name="scene\_type",

sampler\_type=dd\.SamplerType\.CATEGORY,

params=dd\.CategorySamplerParams\(values=\[

"awarehouseloadingarea",

"anurbanintersection",

"amountaintrail",

\]\),

\)\)

builder\.add\_column\(dd\.ImageColumnConfig\(

name="scene\_image",

prompt=\(

"Createaphotorealisticimageof\{\{scene\_type\}\}"

"withclearforegroundandbackgrounddetails\."

\),

model\_alias="my\-image\-model\-alias",

\)\)

builder\.add\_column\(dd\.LLMTextColumnConfig\(

name="scene\_caption",

prompt=\(

"Writeconcise,accessiblealttextforthesupplied"

"image\.Mentionthesettingandthemostimportantobjects\."

\),

model\_alias="my\-multimodal\-model\-alias",

multi\_modal\_context=\[

dd\.ImageContext\(column\_name="scene\_image"\),

\],

\)\)

Listing 8:Image generation followed by multimodal text generation\. Both aliases are user\-configured placeholders\.For seed datasets that already contain image URLs, the same pattern can useImageContext\(column\_name="source\_image", data\_type=dd\.ModalityDataType\.URL\)\. Generated image paths are resolved when used as downstream context; externally hosted URLs must remain accessible to the selected model endpoint\.

### B\.5Validation Columns

Validation columns attach executable quality checks to generated fields\. Listing[9](https://arxiv.org/html/2609.17699#LST9)uses the Python\-code validator pattern; the same validator interface also supports SQL dialect validation, local callables, and remote HTTP validators\.

builder\.add\_column\(

dd\.LLMCodeColumnConfig\(

name="sorting\_algorithm",

prompt="WriteaPythonfunctiontosortalistusingbubblesort\.",

code\_lang="python",

model\_alias="my\-model\-alias",

\)

\)

builder\.add\_column\(

dd\.ValidationColumnConfig\(

name="code\_validation",

target\_columns=\["sorting\_algorithm"\],

validator\_type="code",

validator\_params=dd\.CodeValidatorParams\(

code\_lang=dd\.CodeLang\.PYTHON,

\),

batch\_size=10,

drop=False,

\)

\)

Listing 9:Code\-generation and validation\-column excerpt\. The validation result is retained becausedrop=False\.
### B\.6Export Views

Processors transform generated batches or final datasets outside the per\-column generation path\. The built\-in drop\-columns processor removes intermediate fields from the primary output, while the schema\-transform processor writes an additional transformed dataset view\. Listing[10](https://arxiv.org/html/2609.17699#LST10)shows both patterns\.

builder\.add\_processor\(dd\.DropColumnsProcessorConfig\(

name="cleanup",

column\_names=\["scratch\_work","raw\_context"\],

\)\)

builder\.add\_processor\(dd\.SchemaTransformProcessorConfig\(

name="chat\_format",

template=\{"messages":\[

\{"role":"user","content":"\{\{question\}\}"\},

\{"role":"assistant","content":"\{\{answer\}\}"\},

\]\},

\)\)

Listing 10:Processor excerpt for cleanup and a chat\-format export view\.
### B\.7MCP Tool Traces

For tool\-use data, NDD can expose Model Context Protocol tools to an LLM column and capture the conversation as a side\-effect trace column\. Listing[11](https://arxiv.org/html/2609.17699#LST11)is an excerpt of the basic MCP pattern: the provider name must correspond to a local or remote MCP provider registered by the application before execution, and the resulting trace is written tofact\_response\_\_trace\.

tool\_config=dd\.ToolConfig\(

tool\_alias="basic\-tools",

providers=\["demo\-mcp"\],

allow\_tools=\["get\_fact"\],

max\_tool\_call\_turns=5,

timeout\_sec=30\.0,

\)

builder=dd\.DataDesignerConfigBuilder\(tool\_configs=\[tool\_config\]\)

builder\.add\_column\(

dd\.LLMTextColumnConfig\(

name="fact\_response",

model\_alias="my\-model\-alias",

prompt=\(

"Usetheget\_facttooltolookupinformationabout"

"'\{\{topic\}\}',thenwriteaone\-sentencesummary\."

\),

system\_prompt=\(

"Youmustcalltheget\_facttoolbeforeanswering\."

"Onlyuseinformationfromtoolresults\."

\),

tool\_alias="basic\-tools",

with\_trace=dd\.TraceType\.ALL\_MESSAGES,

\)

\)

Listing 11:MCP tool\-use and trace\-capture excerpt\. Thewith\_tracesetting requests full message history\.
### B\.8Minimal Column\-Generator Plugin

A reusable column type consists of a configuration class, an implementation, a plugin descriptor, and a package entry point\. Listing[12](https://arxiv.org/html/2609.17699#LST12)shows these pieces for a small plugin that multiplies each row index by a configurable value, followed by its use in a dataset configuration\. The files are shown together for brevity but remain separate in the installed package\.

fromtypingimportLiteral

fromdata\_designer\.config\.baseimportSingleColumnConfig

classIndexMultiplierColumnConfig\(SingleColumnConfig\):

column\_type:Literal\["index\-multiplier"\]="index\-multiplier"

multiplier:int=2

@property

defrequired\_columns\(self\)\-\>list\[str\]:

return\[\]

@property

defside\_effect\_columns\(self\)\-\>list\[str\]:

return\[\]

importpandasaspd

fromdata\_designer\.engine\.column\_generators\.generators\.baseimport\(

ColumnGeneratorFullColumn,

\)

fromdata\_designer\_index\_multiplier\.configimport\(

IndexMultiplierColumnConfig,

\)

classIndexMultiplierColumnGenerator\(

ColumnGeneratorFullColumn\[IndexMultiplierColumnConfig\]

\):

defgenerate\(self,data:pd\.DataFrame\)\-\>pd\.DataFrame:

data\[self\.config\.name\]=data\.index\*self\.config\.multiplier

returndata

fromdata\_designer\.pluginsimportPlugin,PluginType

plugin=Plugin\(

config\_qualified\_name=\(

"data\_designer\_index\_multiplier\.config\."

"IndexMultiplierColumnConfig"

\),

impl\_qualified\_name=\(

"data\_designer\_index\_multiplier\.impl\."

"IndexMultiplierColumnGenerator"

\),

plugin\_type=PluginType\.COLUMN\_GENERATOR,

\)

fromdata\_designer\_index\_multiplier\.configimport\(

IndexMultiplierColumnConfig,

\)

builder\.add\_column\(IndexMultiplierColumnConfig\(

name="scaled\_index",

multiplier=5,

\)\)

Listing 12:Core components of a minimal column\-generator plugin and its use in a dataset configuration\.

## Appendix CModel Runtime and Request Admission

This appendix expands the model\-runtime summary in Section[2\.4](https://arxiv.org/html/2609.17699#S2.SS4)\. These mechanics determine how a ready model\-backed cell reaches an external endpoint; they do not change the declarative column graph or its data\-design semantics\.

### C\.1Model Facade and Client Stack

At runtime, theModelRegistryindexes model configurations by alias and lazily constructs aModelFacadewhen an alias is first requested\. The registry provides a single resolution point for column generators and coordinates shared request\-capacity state for aliases that target the same provider and model\. Column generators consequently request a model by alias rather than selecting an HTTP adapter or managing a client lifecycle directly\. Figure[10](https://arxiv.org/html/2609.17699#A3.F10)summarizes this stack and its request\-admission path\.

![Refer to caption](https://arxiv.org/html/2609.17699v1/figures/ndd_model_client_stack.png)Figure 10:Model client stack\.A column generator resolves a logical model alias through the registry and facade\. The request executor acquires capacity from the shared adaptive admission controller before invoking the provider client, then releases the lease with the classified outcome\. AIMD feedback, admission queues, and cooldowns regulate concurrency at the endpoint boundary\.TheModelFacadeis the common inference interface exposed to the engine\. It provides blocking and awaitable operations for chat completion, embeddings, and image generation, and combines model\-level inference parameters with provider\-wide request extensions\. It centralizes prompt and message construction, output parsing, structured\-response validation, correction messages, conversation restarts, multimodal context, MCP tool\-use loops, trace construction, and model\-usage accounting\.

For tool\-enabled generation, the facade supplies tool schemas to the model, executes requested tools through the MCP integration, returns observations to the conversation, and continues until the model produces a final response or reaches the configured tool\-turn limit\. For structured generation, a parsing failure may trigger an in\-conversation correction or a complete conversation restart according toRunConfig\. The resulting message history can be retained as a trace column rather than discarded after the final value is produced\.

Below the facade, provider adapters translate canonical NDD request and response types into the provider’s wire format\. Native clients support OpenAI\-compatible APIs and the Anthropic Messages API\. Hosted services, centralized gateways, and self\-hosted OpenAI\-compatible servers therefore share the same registry and facade path, while provider\-specific response objects and error formats are normalized before returning to the engine\.

### C\.2Adaptive Request Admission and AIMD

NDD inserts a request\-admission layer between the facade and each provider client\. ItsModelRequestExecutorwraps the model\-client interface and intercepts each concrete outbound attempt\. It maps the call to a canonical request resource identified by provider, underlying model identifier, and request domain—chat, embedding, image, or health check—and acquires a lease from the sharedAdaptiveRequestAdmissionControllerbefore invoking the provider\.

Each lease represents one admitted request and is released with a classified outcome\. Success, rate limiting, timeout, provider failure, local cancellation, and unexpected failure all release the exact lease that was acquired\. Requests that cannot immediately obtain capacity wait in an admission queue\. This acquire–call–release boundary prevents permits from leaking on exceptions or cancellation and exposes in\-flight calls, queued requests, cooldowns, and active capacity for observation\.

The configuredmax\_parallel\_requestsvalue supplies a hard concurrency ceiling for a provider–model pair\. Below that ceiling, the controller uses additive\-increase/multiplicative\-decrease \(AIMD\) feedback to adapt to observed endpoint capacity\. An optional startup ramp begins a request domain at one concurrent call and increases toward its configured limit\. When the provider returns HTTP 429, the controller applies the provider’sRetry\-Afterinterval, or a configured fallback cooldown, and multiplicatively reduces the active limit\. After a configurable window of successful requests, it additively restores capacity until it reaches the ceiling\.

Rate limiting is separated from ordinary retry behavior\. HTTP 429 responses remain visible because they drive AIMD\. Eligible transient connection failures and selected server errors follow a separate retry and exponential\-backoff policy, with every concrete retry attempt passing through request admission\. This prevents retries from creating additional load while an endpoint is already signaling that it is over capacity\.

Aliases resolving to the same provider and underlying model share a global request cap, so separate generator and judge aliases cannot independently exceed the capacity assigned to the same upstream model\. Adaptive state remains separate by request domain, allowing chat, embedding, image, and health\-check traffic to respond to their own outcomes while staying bounded by the shared model\-level limit\. The dataset scheduler decides which cells are ready; request admission decides when a ready cell may issue a concrete provider request\.

## Appendix DOperational Deployment and Capacity Planning

This appendix describes user\-managed deployment patterns for running multiple independent NDD execution units\. Scheduler configuration, resource allocation, work partitioning, job submission, and output consolidation remain outside NDD and are supplied by the user\. Within each process, NDD compiles column dependencies, schedules ready work, adapts request admission, applies retries and validation, and materializes checkpoints and output artifacts\.

A separate deployment plan determines how work is partitioned, how many jobs are launched, which resources are assigned to each job, and how their outputs are named and consolidated\. This allows the same dataset configuration to run in a workstation process, a batch allocation, or a set of scheduler\-managed jobs without embedding infrastructure\-specific orchestration in the dataset specification\. Figure[4](https://arxiv.org/html/2609.17699#S2.F4)summarizes the single\-job and sharded architectures introduced in Section[2\.7](https://arxiv.org/html/2609.17699#S2.SS7)\. This appendix develops their operational implications, including capacity measurement, scheduler integration, artifact isolation, and reproducibility\.

When a deployment plan launches multiple jobs, each job owns a separate NDD runtime, checkpoint state, and artifact namespace\. The plan must assign non\-overlapping shards and distinct dataset names\. Adaptive request\-admission state remains local to each process, so the deployment plan must also bound the aggregate request ceilings of jobs that share a gateway or serving pool\.

### D\.1Pilot\-Based Capacity Planning

Efficient large\-scale generation requires planning before scheduler submission\. For a fixed NDD configuration, operators should first run a few representative single\-job pilots using the intended model providers, validation stages, trace settings, and artifact format\. The pilots should record at least:

- •accepted records per unit time and model calls per accepted record;
- •request latency, retry counts, throttling responses, and cooldown time;
- •host memory utilization and local or remote I/O volume, together with CPU utilization when local validators, processors, or serialization are compute\-intensive;
- •for self\-hosted model endpoints, per\-GPU utilization and GPU memory usage;
- •checkpoint size, artifact growth, and the fraction of rejected records\.

For self\-hosted endpoints, the pilot matrix should also vary the serving configuration\. Relevant choices include tensor\-parallel degree, the number of model replicas, server\-side batching or token limits, and endpoint request concurrency\. Increasing tensor parallelism may be necessary to fit a model or reduce per\-request latency, but cross\-GPU communication means that it does not necessarily maximize aggregate throughput\. When the model fits on fewer GPUs, additional replicas may instead provide higher throughput\. Operators should select the configuration that provides the best sustained accepted\-record throughput while maintaining acceptable latency, GPU memory headroom, and stability under the expected request mix\. These are serving\-layer decisions; NDD observes the resulting endpoint behavior but does not configure the model server’s parallelism strategy\.

The pilot measurements inform the job count and shard size selected by the deployment plan\. Throughput should not be assumed to scale linearly with the number of jobs, particularly when jobs share model endpoints, gateways, or storage\. The plan must account for aggregate endpoint throughput, provider quotas, available scheduler resources, storage and network bandwidth, and cost limits\. It should record the configuration version, shard size, per\-job resources, endpoint topology, request ceilings, and artifact layout so that the generation can be reproduced or revised\.

### D\.2Scheduler Integration

The deployment plan may be implemented by any environment capable of launching isolated processes with shard\-specific arguments\. For example, a Slurm job array can map one array task to one dataset shard:

```
#!/bin/bash
#SBATCH --job-name=dd-generate
#SBATCH --array=0-31
#SBATCH --cpus-per-task=16
#SBATCH --mem=64G

DATASET_ROOT="/some/path/my_dataset"

srun python run_shard.py \
  --shard-id "${SLURM_ARRAY_TASK_ID}" \
  --num-shards "${SLURM_ARRAY_TASK_COUNT}" \
  --artifact-path "${DATASET_ROOT}" \
  --dataset-name "${SLURM_ARRAY_TASK_ID}" \
  --resume if_possible
```

Here,run\_shard\.pyis a user\-supplied launcher; the command\-line arguments shown above belong to that launcher rather than to the NDD CLI\. The launcher selects the assigned partition, constructs the shared NDD configuration, and invokescreate\(\)with the common root asartifact\_pathand the array task ID asdataset\_name\. The API constructs the base dataset path asartifact\_path/dataset\_name; task 7 therefore writes beneath/some/path/my\_dataset/7\. PassingResumeMode\.IF\_POSSIBLEorResumeMode\.ALWAYSallows a retry to reuse that shard’s checkpoint state\.

Because every task uses the same artifact root, the shard directories remain grouped beneath one dataset namespace while the task\-ID dataset names prevent jobs from overwriting one another\. Resource requests, array width, retry policy, and dependency handling remain deployment decisions owned by the user and the scheduler\. A reliable sharded run also uses an immutable, identifiable configuration, assigns non\-overlapping shards, writes each job to an independent artifact namespace, and retains shard metadata, rejection diagnostics, and trace provenance during consolidation\.