Simula: A Smarter Way to Generate Synthetic Datasets by Thinking from First Principles

Synthetic data is one of those things everyone talks about but few get right. The pitch is simple: AI models need tons of data, real-world data is expensive, scarce, or privacy-sensitive, so just generate your own. In practice, most current methods are sloppy — they rely on manual prompts, messy evolutionary algorithms, or a pile of seed data that biases everything from the start.

Google Research has been poking at this problem, and their latest paper — published in Transactions on Machine Learning Research — introduces a framework called Simula that takes a different angle. Instead of generating one sample at a time and hoping the dataset works out, Simula treats the whole dataset as a design problem. Think mechanism design, but for data.

The core idea: reasoning-first, seedless, and agentic

The key shift with Simula is that it doesn’t start with existing data. No seed examples, no hand-picked samples. It uses reasoning models to build the dataset from first principles. That means it maps out the conceptual space of a domain, figures out what kinds of examples are needed, and then generates them. The generation capabilities improve naturally as the underlying reasoning models get better.

This is a big deal for domains where data is inherently scarce or sensitive — think cybersecurity, medical diagnostics, or safety-critical edge cases. You can’t always wait for real-world incidents to harden your models. Simula lets you proactively generate the scenarios you need.

Four axes of control

What I like about Simula is that it breaks down generation into four controllable steps, rather than throwing everything into a black box:

1. Global Diversification — Instead of random sampling, Simula uses reasoning to build deep, hierarchical taxonomies of the target domain. This acts as a “sampling scaffold.” You can control global diversity by defining sampling strategies over these taxonomies, ensuring the dataset covers the long tail rather than clustering around common modes.

1. Complexity Calibration — Not all examples are created equal. Simula lets you dial in the complexity of generated data independently from coverage and quality. This is crucial for benchmarking and stress-testing models at different difficulty levels.

1. Quality Filtering — The framework includes a critic model that evaluates generated samples against your criteria, filtering out low-quality or redundant entries. This isn’t a one-time pass; the critic iterates during the generation process.

1. Resource Allocation — Because Simula operates at the dataset level, you can allocate generation resources (compute, tokens, time) strategically across different parts of the taxonomy. Want more edge cases in a specific sub-domain? You can prioritize that.

Why this beats the old way

Most synthetic data pipelines I’ve seen are sample-level optimizers. They generate one data point, check if it’s good, tweak the prompt, repeat. That works for small experiments but falls apart at scale. You end up with datasets that are biased toward whatever the seed data looked like, with no real control over the overall distribution.

Simula flips that. By reasoning about the entire dataset structure upfront, it avoids the “more of the same” problem. The taxonomy-driven approach ensures you’re not just generating more data, but the right kind of data. For production use cases — where coverage, complexity, and quality are independent variables — this is a much more rigorous approach.

The practical upside

Google is pitching this as a solution for “programmable workflows” where data is treated like code — versioned, reproducible, and inspectable. That’s a nice way of saying you can iterate faster. Instead of spending months curating a real-world dataset, you can generate a synthetic one, test your model, find gaps, and regenerate. The whole cycle becomes tighter.

There’s also a preparedness angle that I think is underappreciated. With synthetic data, you can generate edge cases that haven’t happened in the wild yet. That’s huge for safety and robustness. You don’t have to wait for a failure to harden your model; you can proactively stress-test it against plausible scenarios.

What I’m watching

Simula is still research-stage, and I’m curious how it performs in practice across different domains. The framework is only as good as the underlying reasoning models, and those are improving fast. The paper is worth a read if you’re working on data generation or model evaluation.

One thing that bugs me: the paper doesn’t go deep into the computational cost of all this reasoning-driven taxonomy building. Building hierarchical taxonomies from scratch with a reasoning model isn’t cheap. I’d like to see a cost-benefit analysis comparing this to simpler methods.

Still, the direction is right. We need more rigorous approaches to synthetic data, and reasoning from first principles is a solid bet. Simula is one to watch.