Simula: Why Google Thinks Synthetic Data Needs Better Architecture, Not Just More Prompts

The data bottleneck nobody’s talking about

Generalist AI models have gotten scary good because they’ve been fed the entire internet. But the next wave of useful AI won’t be about knowing everything — it’ll be about specializing in things that barely exist yet. Think rare medical conditions, niche industrial safety scenarios, or privacy-sensitive domains where you can’t just scrape data.

Real-world data has three problems that are getting harder to ignore:

• Cost and accessibility: Manually curating specialized datasets is stupidly expensive, slow, and error-prone.
• Operational drag: Real data is static. You collect it, you’re stuck with it. Synthetic data, on the other hand, can be version-controlled, inspected, and regenerated like code. That’s a huge advantage when you’re iterating fast.
• Preparedness: Waiting for accidents to happen in the wild before you harden your models is a reactive game. Synthetic data lets you generate edge cases that haven’t occurred yet and stress-test proactively.

Synthetic data sounds like the obvious fix, but current generation methods are sloppy. Most rely on manual prompting, evolutionary algorithms, or large seed datasets from the target distribution. These approaches don’t scale well, they’re black boxes, and they give you very little control over what the dataset actually covers.

Worst of all, they operate at the sample level — optimizing one data point at a time — rather than designing the dataset as a coherent whole.

Mechanism design for datasets

Google Research’s answer to this is Simula, a framework they introduced in a paper published in Transactions on Machine Learning Research. The core idea is deceptively simple: treat synthetic data generation as a mechanism design problem, not a generation problem.

Instead of asking “how do I generate more samples?”, Simula asks “how do I allocate resources across my dataset to ensure coverage, complexity, and quality are independently controllable?”

This is a meaningful shift. Production use cases don’t just need more data — they need the right data. They need the long tail of a domain, not just the fat middle where everything clusters.

How Simula works: reasoning-first, seedless, agentic

The framework decomposes generation into four steps, each controllable:

1. Global Diversification

Instead of random sampling, Simula uses reasoning models to map the conceptual space of a target domain into deep, hierarchical taxonomies. This is the “sampling scaffold.” By defining sampling strategies over these taxonomies, you control global diversity — ensuring the dataset covers rare edge cases rather than clustering around common modes.

The process is recursive: at each depth level, the system generates candidate sub-categories (proposals), then evaluates, merges, and filters them with a critic model. This “propose-and-refine” loop builds a dense taxonomy dynamically, without any human seed data. The paper uses a Cyber Threat Intelligence tree as an example, but the approach is domain-agnostic.

2. Local Generation

Once the taxonomy is built, Simula generates individual samples within each node. Because the scaffold already ensures coverage, the generation step can focus purely on quality and complexity.

3. Quality Control

This isn’t a one-shot generation. Simula includes a critic model that evaluates each sample against quality criteria and can request regeneration if something’s off. This is more robust than filtering after generation because it guides the process iteratively.

4. Dataset Assembly

Finally, samples are assembled into a dataset with controllable proportions across the taxonomy. You can decide, for example, that 5% of your dataset should cover extremely rare edge cases, while 40% covers common scenarios. This is where the mechanism design angle really shines — you’re allocating a budget across categories.

Why this matters

The most interesting implication is that Simula’s generation capabilities improve naturally as the reasoning capabilities of the underlying models advance. Since the framework relies on reasoning for taxonomy construction and sample generation, better reasoning models directly translate to better synthetic datasets. No manual retooling required.

This is also a seedless approach. You don’t need a pile of existing data to bootstrap. You start from first principles — defining the domain conceptually, then letting the reasoning model explore and map it.

The catch

Simula is not a magic bullet. It’s computationally expensive — running recursive propose-and-refine loops with critic models costs more than a single prompt-based generation. The paper doesn’t fully address the cost-benefit tradeoff for smaller teams or simpler use cases.

Also, the quality of the output is still bounded by the reasoning capability of the underlying model. If your model can’t reason well about a niche domain, the taxonomies will be shallow and the samples will be mediocre. This is less of a problem with frontier models, but for specialized domains where even frontier models struggle, you might still need human oversight.

My take

I’ve seen too many synthetic data pipelines that are just glorified prompt templates with some random sampling bolted on. They produce datasets that look good on paper but fail in production because they don’t cover the long tail. Simula’s approach of treating dataset design as a resource allocation problem is the right framing.

The taxonomy-first methodology is also refreshing. Most synthetic data tools focus on generating samples and then filtering, which is backwards. You should design the structure first, then fill it. That’s basic engineering discipline, but it’s rarely applied to data.

I’d like to see more practical benchmarks comparing Simula-generated datasets against manually curated ones for specific downstream tasks. The paper focuses on the methodology, but the real test is whether models trained on Simula data actually perform better in the wild.

Still, this is one of the more thoughtful approaches to synthetic data I’ve seen in a while. It’s not just about generating more — it’s about generating with intent.