Inspiration
Every important business decision is based on a mental model of how a system behaves. Operations managers reason about queues, supply chains, and staffing; data scientists reason about uncertainty and interventions; researchers reason about stochastic processes. Yet transforming these mental models into rigorous mathematical simulations typically requires specialized expertise in statistics, simulation, and programming.
We asked a simple question:
What if describing a system in natural language were enough to build an executable model?
That question became SimCore Studio—an AI-powered modeling environment that bridges the gap between human expertise and formal simulation. By combining OpenAI models with deterministic simulation engines, SimCore Studio enables users to move from conversational problem descriptions to transparent, executable, and reproducible decision models.
What it does
SimCore Studio is an AI-powered Modeling IDE for building executable decision models from natural language.
Instead of writing code or mathematical equations, users describe the system they want to analyze in plain English. The AI Modeling Agent conducts an interactive interview, identifies missing assumptions, and transforms the conversation into a structured Intermediate Representation (IR). The IR is then validated by deterministic Python logic, routed to the appropriate simulation engine, executed, and finally translated back into clear, business-oriented insights.
With SimCore Studio, users can:
- describe complex systems conversationally;
- refine assumptions through an AI-guided interview;
- generate transparent, auditable, and reproducible simulation models;
- execute Monte Carlo, Gillespie (SSA), or causal inference analyses;
- compare alternative scenarios through "what-if" analysis;
- receive both statistical results and natural-language explanations that support decision making.
Rather than asking users to learn simulation languages, SimCore Studio allows them to think in the language of their domain while AI handles the translation into formal mathematical models.
Why AI?
Traditional simulation software assumes users already know how to formulate mathematical models before opening the tool.
SimCore Studio reverses that workflow.
OpenAI models are not used to generate executable code or replace mathematical simulation. Instead, they serve as an intelligent modeling assistant that elicits assumptions, resolves ambiguity through conversation, and translates human intent into a deterministic, executable specification.
By separating AI-driven model generation from deterministic model execution, we combine the flexibility of natural language with the reliability, transparency, and reproducibility required for scientific and business decision-making.
How we built it
We built SimCore Studio using Python 3.11, Streamlit, NumPy, SQLite, and the OpenAI API, creating an IDE-like environment for authoring, validating, executing, and revisiting simulation models.
The system follows a compiler-inspired architecture:
Natural Language
│
▼
AI Modeling Agent
│
▼
Structured YAML Intermediate Representation
│
▼
Deterministic Validator
│
▼
Simulation Engine
│
▼
AI Interpretation Agent
│
▼
Decision Insights
1. AI Modeling Agent
The Modeling Agent interviews users about the system they wish to model. Instead of immediately generating simulations, it asks clarifying questions, uncovers missing assumptions, and converts the conversation into a strict YAML Intermediate Representation.
To maximize reliability, we employed structured prompting techniques including XML-style delimiters, priority-ordered instructions, canonical examples, and schema-constrained outputs, ensuring the model produces formal specifications rather than free-form code.
2. Deterministic Validator
The validator parses the YAML IR and performs comprehensive consistency checks, including required parameters, probability constraints, simulation settings, and structural correctness. It also determines which simulation engine is appropriate for the specified model.
Only validated models proceed to execution.
3. Simulation Engines
The validated IR can be executed using multiple deterministic simulation engines:
- Monte Carlo Simulation for uncertainty propagation, forecasting, inventory analysis, finance, and queueing systems.
- Gillespie Stochastic Simulation Algorithm (SSA) for continuous-time stochastic processes commonly encountered in systems biology, chemistry, and epidemiology.
- Causal Inference Engine supporting Structural Causal Models and intervention analysis, including estimation of counterfactual quantities such as $\mathbb{E}[Y \mid do(X=x)]$.
Each engine shares the same Intermediate Representation, allowing the architecture to be extended with additional modeling paradigms in the future.
4. AI Interpretation Agent
After simulation, the Interpretation Agent converts statistical outputs—including means, confidence intervals, and distribution summaries—into concise, decision-oriented explanations tailored to business users.
To support iterative workflows, we implemented SQLite-based persistence (history.db), allowing users to save, reload, and refine previous modeling sessions.
Challenges we ran into
Our biggest challenge was balancing the flexibility of large language models with the rigor required for mathematical modeling.
When asked to build simulations, LLMs naturally attempt to fill in missing parameters, invent assumptions, or generate executable code. While helpful in general programming tasks, this behavior is unacceptable in simulation: a fabricated arrival rate or transition probability can fundamentally change the resulting analysis.
To address this, we designed a strict contract between the AI layer and the execution layer.
Rather than generating executable programs, the LLM produces a structured Intermediate Representation that must pass deterministic validation before any simulation is executed. Missing information is surfaced through follow-up questions instead of being silently invented.
Designing prompts that preserved model state during iterative "what-if" conversations while preventing hallucinated updates required extensive experimentation and prompt engineering.
Accomplishments that we're proud of
We are proud that SimCore Studio combines the conversational capabilities of modern LLMs with the rigor of deterministic mathematical modeling.
Highlights include:
- designing a compiler-style architecture where AI translates natural language into a formal Intermediate Representation rather than executable code;
- implementing native NumPy simulation engines for Monte Carlo, Gillespie (SSA), and causal inference;
- creating an inspectable, editable, and reproducible YAML IR;
- separating AI-driven model generation from deterministic execution to reduce hallucination risk and improve trust;
- enabling users to progress from an informal business question to rigorous simulation results within a single conversational workflow.
What we learned
One of the most powerful applications of LLMs is not code generation—it is structured translation.
By treating the language model as a compiler from human intent into a formal executable specification, we combined the expressiveness of natural language with the reliability of traditional simulation software.
Throughout the project, we also learned the importance of carefully defining the boundaries between probabilistic AI and deterministic computation. Prompt structure, explicit schemas, XML delimiters, canonical examples, and strict validation collectively proved far more effective than relying on increasingly complex prompts alone.
What's next for SimCore Studio
Our vision extends well beyond stochastic simulation.
The same architecture can support additional modeling paradigms, including agent-based modeling, system dynamics, optimization, and digital twins. Future versions will integrate directly with enterprise data platforms such as SQL databases and Snowflake, allowing simulation parameters to be estimated automatically from operational data.
Ultimately, we envision SimCore Studio as an AI Modeling IDE—a platform where analysts, scientists, and domain experts collaborate with AI to transform natural-language descriptions into transparent, executable models that support better decisions.
Log in or sign up for Devpost to join the conversation.