Gimle Labs Presentation
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 typed circuit graphs where composition preserves correctness by construction. Feedback loops, the heart of real dynamical systems, compile into traced circuits with verified fixed-point semantics, not approximated as recurrent black boxes. 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 language of dynamical systems on unlimited synthetic data. Every output is a syntactically valid circuit by construction.
Semantics
Simulation-Grounded Training
Train on what circuits do, not just how they look. The simulator becomes part of the loss, so the model learns that structure determines dynamics.
Search
Reinforcement Learning
Explore the space of possible systems, guided by simulation-verified rewards. Algebraic rules narrow the search before the network sees it.
Precision
Iterative Refinement
A learned process that refines candidates toward exact target dynamics — 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.
Beyond Prediction
The model is the beginning. The language is the platform.
Within a few years, every serious lab will have neural surrogates that predict physical systems. Prediction will be commodity. What sets Gimle apart is not the forecast — it's the artifact it produces: a machine-readable, composable, verifiable representation of the system's dynamics.
That artifact is a language. And once machines can read and write the language of physics, a long tail of capabilities opens up that a black-box predictor structurally cannot provide.
The LLM Parallel
GPT-3 looked like better autocomplete. It turned out to be the platform underneath agents, Claude Code, and modern reasoning systems.
A foundation model for dynamics is the same bet. Predicting trajectories is the visible use case. Learning the language of physics is what makes everything downstream possible.
Inverse Design
Specify the behavior you want and the model writes the system that produces it. A fundamentally different problem than prediction and one only a generative model of structure can solve.
Cross-Domain Transfer
A battery circuit and a metabolic pathway share structure in the same language. Knowledge learned in one domain compounds across all of them.
Agentic Discovery
Agents that reason symbolically over real systems, forming hypotheses, running verified simulations, refining models autonomously.
Verified Autonomy
Control synthesis with formal guarantees on stability, reachability, and safety, guarantees that hold out-of-sample, where black-box models fail.
Composable Physics
Every discovered system is a reusable building block. Models snap together across domains the way software libraries do.
The Long Tail
General-purpose languages grow capabilities never anticipated. The most valuable uses of a physics foundation model are not imagined yet.
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.
LLMs began as autocomplete and became the layer everything built on top of language now runs through. Gimle begins as a simulator and becomes the same kind of layer for physics.
Not just prediction or approximation, but a true understanding of the physical world.