OpenWave Uses AI to Generate Particle Simulation Code

The OpenWave repository published an approach this week that deserves attention: instead of a physicist manually writing simulation code to validate particle models, an AI agent generates that code autonomously within a controlled environment. The release surfaced on Hacker News on June 18 with modest traction (1 point, 1 comment), but the pattern it describes is more interesting than the social signal suggests.

OpenWave's proposal is concrete: the environment runs the agent, the agent produces simulation code, and that code is used directly to test new hypotheses about particle behavior. There is no human in the loop for each code iteration; the human defines the model to test and the system handles the rest.

What OpenWave Does Exactly

According to the repository's `MODELS.md` file, the project defines a description layer for particle models that the agent reads as context. From there, it generates simulations in code (the language is not explicitly specified in available sources) that implement those models so they can be executed and compared against reference data.

This is not code generation on the fly in a chat: the design implies the agent operates within an environment, probably an execution loop with access to tools, capable of writing files, running them, and feeding back results. In Claude ecosystem terms, this is the type of workflow implemented today with Claude Code plus sub-agents or MCP servers that expose code execution and result-reading tools.

Why This Matters for the Tool Ecosystem

The use case represents a category gaining momentum: domains where the bottleneck is not understanding the physics, but translating formal models into executable code quickly and reproducibly. Researchers working in theoretical physics or computational modeling know this friction well: the conceptual model is clear, but writing, debugging, and maintaining simulation code consumes hours that could go toward analysis.

When the agent assumes that layer, the researcher can iterate over models much faster. The obvious risk is validation: automatically generated code can be syntactically correct and physically incorrect. OpenWave does not detail in available sources how it handles that verification, which is precisely the critical part.

From a technical implementation standpoint, projects like this typically rely on some combination of:

• A context system that describes the domain (here, particle models in `MODELS.md`)
• An execution loop that lets the agent run generated code and read output
• Some mechanism for automated evaluation that compares results against expected values

This aligns well with patterns built today on Claude Code using `PostToolUse` hooks to capture execution results, or MCP servers that expose simulation environments as invocable tools.

Who Gets Real Value from This

The immediate audience is small research groups with limited computational resources and no dedicated software team. For them, an agent that writes simulation scaffolding can be the difference between iterating in days or weeks.

There is also interest from engineering teams working on physical model validation in industry, semiconductors, fluid dynamics, materials, where the pattern is analogous: formal model → simulation code → comparison with benchmark.

OpenWave is a small project and available sources lack implementation detail. It is worth monitoring as the repository gains more documentation, but the approach, an environment delegating simulation code generation to an agent, points in a direction that has practical sense.

---

EP: This case is a good example that the most solid uses of code agents are not in generic tasks, but in domains with well-defined formal structure. Particle physics, with its explicit mathematical models, is a reasonable candidate for this kind of automation.