A recent episode of Latent Space with Joon Sung Park, co-founder of Simile AI, caused a strange flashback to my student days in industrial engineering. Long before anyone talked about generative AI, we learned to use a piece of software called Arena to build probabilistic simulations of airports, supermarkets, factories, and other complex systems.

The basic idea was simple and surprisingly powerful. Instead of changing the real system, you built a simplified version of it on a computer. Customers arrived according to some probability distribution. A cashier took a variable amount of time to serve them. Queues formed, resources became occupied and available again. You could add another checkout lane, change the staffing level, or rearrange a production line, run the simulation thousands of times, and see what happened before spending money in the real world.

Arena still exists, by the way. Rockwell Automation owns it today, and it remains a commercial simulation product used for manufacturing, logistics, healthcare, and other process-heavy systems. Its core technique is still discrete-event simulation, although the product has expanded beyond that.

The podcast sent me down a rabbit hole. I wanted to know what had happened to this world of simulation since I last touched it.

It turns out quite a lot has happened. But the most interesting change may be happening right now.

But First, Some History

Computer simulation goes almost as far back as general-purpose computing itself. One foundational technique, the Monte Carlo method, emerged at Los Alamos in the 1940s. Stanislaw Ulam and John von Neumann realized that increasingly powerful computers could use repeated random sampling to attack problems that were difficult to solve analytically. Instead of calculating one exact answer, you could run enormous numbers of possible histories and study the distribution of outcomes.

By the 1960s, simulation was important enough to produce programming languages designed specifically for it. One of them was Simula, developed by Ole-Johan Dahl and Kristen Nygaard at the Norwegian Computing Center. Simula represented parts of a simulated system as independent objects containing both data and behavior. That idea escaped simulation entirely and became a foundation of object-oriented programming.

Over the following decades, simulation became a serious engineering discipline. Discrete-event tools such as Arena became particularly useful for operational systems. You could model a hospital, warehouse, airport, or factory as entities moving through processes while competing for resources. That was the version I learned.

And it was already powerful because it gave you a cheap place to be wrong.

If a new production layout reduced throughput rather than increasing it, finding that out inside Arena was dramatically cheaper than finding it out after moving the machines. If another security lane barely changed passenger waiting times because the real bottleneck was somewhere else, you could discover that before building it.

The model was imperfect. That was understood. The airport on the screen was not the real airport; it did not need to be. It only needed to capture enough of the system to make the experiment useful.

Then the Entities Started Behaving

Discrete-event simulation tends to care primarily about what happens to an entity. A customer arrives. They enter a queue. They are served. They leave.

But eventually simulation tools started treating those entities as actors.

Agent-based modeling lets individual components of a system have their own state and behavior and interact with each other. The agent might be a person, vehicle, business, animal, or almost anything else. Modern platforms such as AnyLogic can combine agent-based modeling with discrete-event simulation and system dynamics in the same model.

Human behavior was simulatable long before generative AI.

You could model a supermarket customer who abandons a queue after ten minutes. You could give different types of customers different probabilities of buying a product. You could build state machines describing how people move through a system and rules governing how they react to each other.

But a constraint was hidden inside all of this: someone had to specify the behavior.

The simulation behaved according to the assumptions encoded by the people who built it. If I decided that 20 percent of customers abandon the queue after ten minutes, that rule became part of my artificial world. More sophisticated models could use research data, probability distributions, and complicated behavioral models, but ultimately the designer still had to decide what variables mattered and how they influenced behavior.

That is where generative AI begins to change the picture.

The Big Change Is Not That Behavior Can Be Simulated

Researchers have been building behavioral and agent-based simulations for decades. The change is not whether behavior can be simulated, but how faithfully we can represent its complexity.

Real systems are difficult to simulate not only because they contain many moving parts, but because the people inside them are different. We have different goals, histories, preferences, habits, and levels of patience. Traditional models can capture some of that variation, but only when the designer decides which differences matter and encodes them.

Generative AI changes that boundary. An LLM-based agent can be given memories, goals, history, and context, then produce responses to situations the simulation designer did not explicitly anticipate. Instead of encoding thousands of rules, some behavior can emerge from who the agent is, what it remembers, what it wants, and what is happening around it.

There is something very Blade Runner about that idea. Give an artificial being memories and a history, and those memories begin to shape its behavior. In simulation, that is becoming less of a philosophical thought experiment and more of a practical capability, and it echoes a point I keep returning to about why memory is the missing layer in so much of what we build with these systems, whether the thing being modeled is a workflow or a person.

Much of the real world’s complexity comes from the people inside it. A queue is not just a queue if everyone in it has different priorities and reactions. A market is not just a collection of buyers if those buyers influence one another. Richer individuals could produce richer interactions and feedback loops.

This was the point where the idea stopped feeling like a better version of Arena and started feeling like something genuinely different.

But that introduces a new problem too: a believable simulation is not necessarily an accurate one.

LLMs are exceptionally good at producing behavior that looks plausible to us. That does not mean a simulated person will behave the way a real person would. A population of convincing AI characters could still produce an entirely fictional society.

This is why Park’s work after Generative Agents is more interesting to me than the original demonstration. In a later study, his team created agents representing 1,052 real people based on extensive interviews and then compared the agents’ responses with the people they represented. The goal was not simply to create characters that seemed human. It was to measure how faithfully a simulation could reproduce actual human responses.

That distinction between plausibility and validity will probably determine how useful this entire field becomes.

A Much Bigger Experimental Sandbox

I don’t know whether Simile will eventually simulate eight billion people, and I am skeptical of any claim that we will soon have perfect digital twins of human beings. Humans are difficult enough to predict when we ask them directly what they are going to do.

But perfect fidelity is not the goal of simulation, and it never was.

The airport I built in Arena was not an airport. The arrivals were probability distributions. The service times were probability distributions. The passengers were little entities moving between blocks on a screen.

And yet the model could still tell us something useful about the real system.

That is what makes this new generation of simulation interesting.

For decades we have been increasing the fidelity of the systems around the actors: better physics, better statistics, better operational models, better 3D worlds, and better digital twins. Generative AI may now allow us to increase the fidelity of the actors themselves.

If that works, even imperfectly, the range of experiments we can run before touching reality becomes much larger.

We could simulate not only whether another security lane reduces waiting time, but how different people respond to the change. Not only whether a new store layout improves throughput, but how customers navigate it. Not only whether a policy produces the expected numerical outcome, but how groups adapt, interact, and respond to one another after it is introduced.

Simulation has always been valuable because it gives us a low-cost environment in which to ask, “What happens if we do this?”

AI did not invent that idea. It may simply let the people inside our simulations behave a little more like us.

And as for whether we are all living in a simulation: who cares? As long as we have cookies and the illusion of free will.