Gimle Labs
A foundation model for the dynamics of the physical world.
After three decades of digital revolutions, the coming decades will be dominated by advances in physical world engineering. The bottleneck isn't reasoning — it's computation. The world's most complex systems still can't model themselves.
Gimle changes that.
Reasoning Is Not Simulation
Computers can now reason about physical systems at the level of a senior domain expert. But reasoning is a guess — a fast, intuitive extrapolation from prior knowledge. Simulation is something fundamentally different: it runs the actual equations, calculates, verifies, and tests under conditions never seen before.
As autonomous systems move into the physical world, the gap between reasoning and computing becomes critical. You can't control what you can't simulate. You can't trust what you can't verify.
Reasoning
Extrapolate from prior knowledge — what an LLM does. Fast, intuitive, but fundamentally a guess
Simulation
Run the actual equations — calculate, verify, test under conditions you haven't seen. Slow, rigorous, and trustworthy
Not just reason about the world — compute it.
What's missing is a way for machines to autonomously build the models they need to simulate — to go beyond intuition and actually run the equations.
How Physical Systems Are Modeled Today
Explicit Modeling
The traditional approach
You observe the phenomenon, gather data, and with expert knowledge define a set of governing equations — a qualified guess based on understanding and experience. Gives you the actual system, but it doesn't scale: as systems grow complex, you end up with oversimplified approximations.
✓ Interpretable & trustworthy / ✗ Doesn't scale to complexity
Implicit Modeling
The modern ML approach
Skip the equations. Train a neural network as a functional approximation of the system's input-output behavior. Scales to large datasets — but you lose the explicit equations: no understanding, no what-if scenarios, no out-of-distribution trust.
✓ Scales to large datasets / ✗ Black box — no understanding
Implicitly Learn Explicit Systems
We don't train a model to be the system —
we train it to write the system.
Instead of choosing between fidelity and scale, we use learning to discover the explicit equations. Given observed data and a potential first candidate, we find the governing equations that model that data — faithful, high-fidelity, and verifiable. Not a functional approximation, but the actual system.
A foundation model for the dynamics of the physical world.
The Analogy
You can ask an LLM to multiply numbers, or you can ask it to write a program that multiplies — it's much better at writing programs than at synthesising the answers.
Same principle: we don't train a model to be the system — we train it to write the system.
A New System Representation
The foundation that makes learning possible
A categorical, functional approach to modelling systems — like constructivist programming, but for physics. Systems compile into executable circuit graphs where composition preserves correctness by construction. Any stochastic, deterministic, or discrete system of any complexity can be expressed as a proof in such a proof system.
The same circuit runs deterministic, stochastic (Itô or Stratonovich), or discrete — without rewriting. The syntax is simple and regular, but semantically rich: small structural changes dramatically alter the dynamics. This is what makes it learnable — and what Modelica, Simulink, SPICE or similar modelling frameworks fundamentally lack.
Learnable & Universal
Simple, regular syntax — like code, but for physics. One language for thermal, electrical, mechanical, chemical, biological, and financial systems
Composable
Build large systems from smaller ones. Model a battery, a motor, a controller — then snap them together
Differentiable
JAX-native. Gradients flow through integration, feedback loops, and neural components — enabling parameter fitting and structure search
Verifiable & Interpretable
The output is the actual equations — readable, trustworthy. Algebraic rewrite rules check stability, reachability, and safety invariants symbolically
Training That Goes Beyond Prediction
Staged Training — more AlphaZero than GPT
Syntax
Next-Token Prediction
Learn the grammar of circuit representations on unlimited synthetic data generated by our simulator. Grammar-constrained decoding guarantees every output is syntactically valid.
Semantics
Simulation-Grounded Training
Add losses tied to actual dynamics via Asgard's differentiable simulator. Behavior-aware embeddings encode what a circuit does, not just what it looks like. The model learns that structure determines dynamics.
Search
Reinforcement Learning
RL over the space of circuit structures, guided by simulation-verified rewards. Algebraic rewriting narrows the search space; differentiability enables gradient-guided exploration.
Precision
Iterative Refinement
A learned process that iteratively improves candidates toward precise target dynamics — like AlphaFold's structure refinement, but for dynamical systems.
Why This Is Hard
Simple syntax, extreme semantic sensitivity — a small structural change completely changes the dynamics. More like protein folding than natural language: the space of valid structures is vast, but only a tiny fraction produce the target behavior. Next-token prediction alone learns syntax but misses semantics.
The Stack
Four components that work together in a discovery loop
MIMIR
Foundation Model
The inverse of simulation: given behavior, find the system. Trained on unlimited self-generated data. Grammar-constrained generation guarantees validity; curriculum learning builds from atoms to full complexity.
ASGARD
Simulation & Verification
Traced monoidal category theory — compositional correctness is a theorem. Same equation runs deterministic, Itô, or Stratonovich without rewriting. JAX-native with autodiff through integration, feedback, and neural components.
BIFROST
Integration Layer
Hybrid discovery pipeline connecting neural synthesis, symbolic reasoning, and agentic search. Autonomous hypothesis formation and systematic testing from raw data.
HUGIN
Agentic Reasoning
Immutable stack architecture — every reasoning step is debuggable and replayable. LLMs as oracles, not agents. Built for creative reasoning, not workflow automation.
Where This Matters
Any domain with dynamics you need to understand — not just predict
Scientific Discovery — Labs produce observations they can't model. Gimle finds the governing equations that generated them.
Engineering — Replace hand-built Simulink and Modelica models. Discover system dynamics directly from test data.
Control & Safety — Verified, interpretable models with formal guarantees on stability, reachability, and safety.
Biology & Medicine — Drug interactions, metabolic pathways. Dynamics we observe but rarely understand.
Chemistry & Materials — Reaction kinetics, catalysis, polymer dynamics. Governing equations from experimental data.
Finance — Regime changes, feedback loops, stochastic behavior. Same circuits run deterministic or Monte Carlo paths.
Where This Goes
Writing the equations for a physical system takes deep expertise and months of work. Each model Gimle discovers becomes a reusable, composable component — a growing library of verified dynamics that compounds over time.
Every discovery accelerates the next. A self-expanding atlas of the physical world — built not by hand, but by a machine that learns to see the structure behind the data.
Not just prediction or approximation, but a true understanding of the physical world.