How to generate secure synthetic data with differential privacy

Introduction: Generating useful data without compromising privacy

When training next-generation models such as Block’s full-duplex voice models (Dessa) or AI agent frameworks like Infini-AI-Lab’s Hermit, data quality is paramount. A common problem is how to get enough data for training without violating the privacy of real users. The answer lies insynthetic data

What are synthetic data and differential privacy

Synthetic data

• Computationally generated records that mimic the distribution, relationships, and characteristics of the original dataset.
• Can be used for testing, model development, and sharing across teams without transferring raw data.

Differential privacy

• A mathematical criterion that guarantees that adding or removing a single record has a limited impact on the output of any analysis.
• Implemented by adding statistical noise (e.g., Gaussian noise) to query results or dataset statistics.

Together, these technologies enable the creation of datasets that are useful for training AI models while adhering to strict regulations and preserving user trust.

Why synthetic data with differential privacy is essential for modern models

Recent voice-to-voice models such as Dessa and AI agent platforms like Hermit often require large amounts of labeled audio and metadata. Collecting such data globally can be costly, slow, and legally risky. Synthetic data offers an alternative:

• Speed:Generates data instantly for various training pipelines.
• Privacy:Differential privacy ensures that no single speaker can be identified.
• Flexibility:Allows synthesis of specific scenarios, accents, or domains not present in collected data.

As a result, research teams and engineers are increasingly choosing this combination to comply with regulations such as GDPR and evolving data-privacy laws.

Implementation: Generating synthetic data with DP in 2026

Several mature Python libraries for differential privacy exist. Below is a practical example that demonstrates how to generate a synthetic dataset for a speech-to-text task using the open-source framework **OpenDP** and the synthetic data generator **DiffPrivLib**.

import pandas as pd
import numpy as np

# Simulation of a small dataset of transcripts with user information
data = {
    "text": ["Hello, how are you?", "Book an appointment", "Thanks!"],
    "user_id": [1, 2, 3],
    "duration_sec": [1.2, 3.5, 0.9]
}
df = pd.DataFrame(data)

Add noise to the distribution of phrase lengths using the Gaussian DP mechanism from OpenDP.

from opendp.meas import make_stable_histogram
from opendp.transform import make_privacy_id

# Define a DP mechanism for a histogram of phrase lengths
length_histogram = make_stable_histogram(
    bounds=(0, 10),
    alpha=0.01,  # epsilon budget control
)

# Compute the histogram with noise
noisy_hist = length_histogram(df["duration_sec"].values)
print(noisy_hist)

DiffPrivLib offers a `SyntheticData` model that uses a DP mechanism to synthesize new records.

from diffprivlib.models import SyntheticData

# Initialize the synthetic data generator with an epsilon budget
model = SyntheticData(epsilon=1.0, bounds=[(0, 10), (0, 3)])

# Fit the model to the raw data (again for illustration only)
model.fit(df)

# Generate synthetic data
synthetic_df = model.generate(samples=5)
print(synthetic_df)

The resulting synthetic dataset contains duration values and phrases that follow the original distribution, but with noise added to protect each individual observation.

Real-world use cases: Integrating with voice models and AI agents

1. Training Dessa’s voice model

• Use the synthetic dataset to generate synthetic audio-transcript pairs.
• Because the dataset is DP, you can share it with external research labs without risk.

2. Creating data for Hermit

• AI agents often need heterogeneous interaction logs. Synthetic data provides a diverse test set while keeping user information private.
• Integrate synthetic data into Hermit’s unit tests to evaluate the acquisition of new capabilities.

3. Developing TTS pipelines like AssemblyAI-TTS-1

• Generate synthetic sentences with varied accents and speaking speeds to train the TTS model at a lower cost.
• The DP budget ensures no raw audio samples leak into model distributions.

Best practices and considerations

• Choose the right epsilon:Lower values (e.g., epsilon
• Monitor utility:Compare model metrics trained on synthetic data versus raw data. If performance drops, increase epsilon or use more sophisticated DP mechanisms.
• Document the process:Keep a record of DP mechanisms, budgets, and random seed parameters for reproducibility.
• Understand regulations:Differential privacy alone does not guarantee compliance; ensure the synthetic dataset also meets local privacy regulations.

Actionable takeaway

1. Evaluate a DP pipelinefor your raw data: identify queries or statistics you can release safely.
2. Pick a library(OpenDP, diffprivlib, PyDP) and implement a simple Gaussian or Laplace mechanism.
3. Generate synthetic datausing the DP model to create new records for training LLMs, voice models, or AI agents.
4. Test and iterate:Measure the impact on model performance and adjust epsilon accordingly.

Conclusion