Autonomous Scientific Discovery Agent
Project ATOM • v3.1 Beta • Research Preview
The first AI that knows when it's hallucinating.
ATOM stabilizes chaotic regimes ($Re \ge 1000$) by enforcing Symplectic Energy
Constraints
and gating neural intuition with Symbolic Law Discovery.
Built On
Navier-Stokes equations are computationally irreducible. Simulating a full car aerodynamics run at high-fidelity ($Re > 10^7$) takes weeks on CPU clusters. Engineering iteration crawls to a halt.
Generative AI (GANs/Diffusion) can "draw" fluids, but they violate conservation laws. They create energy from nothing. In safety-critical domains (Nuclear, Aero), hallucination is fatal.
We don't just "train" on physics; we embed it.
By enforcing Divergence-Free Fields ($\nabla \cdot \mathbf{v} = 0$) and
Hamiltonian Conservation ($\frac{dH}{dt} = 0$), ATOM guarantees physical
validity
where Generative AI fails.
System Architecture v3.1
Hover over the diagram to inspect source.
The agent predicts a stream function ($\psi$) rather than raw velocity. Mathematical differentiation guarantees Mass Conservation.
class HelmholtzHead(nn.Module):
""" Enforces Div=0 via Stream Function """
def forward(self, x):
psi = self.proj(x)
# Central Difference (Discrete Curl)
u = (psi[:, 2:] - psi[:, :-2]) / 2.0
v = -(psi[:, 1:-1] - psi[:, 1:-1]) / 2.0
return torch.stack([u, v], dim=-1)
Continuous-time control for continuous-time physics. The network adapts its internal clock speed ($\tau$) dynamically based on turbulence.
class LiquidCell(nn.Module):
def forward(self, input, hidden, time_delta):
# Dynamic Time Constant
tau = torch.sigmoid(self.tau_learner(input))
# ODE Solve (Semi-Implicit)
d_hidden = -hidden / tau + self.synapse(input)
return hidden + d_hidden * time_delta
During the "Sleep Phase," the agent distills neural weights into human-readable differential equations using genetic programming (PySR).
> [SCIENTIST] Waking up...
> [MEMORY] Reading trajectory buffer (Size: 80k)
model = PySRRegressor(
binary_operators=['+', '*', '/', '-'],
unary_operators=['cos', 'exp', 'sin'],
model_selection="best"
)
> DISCOVERED LAW (Bernoulli):
> $R = 20.0 - \frac{1}{v}$
High-fidelity Lattice Boltzmann solver (D3Q27) generates ground truth data using Entropic-Stabilized (KBC) collision models.
stepper = IncompressibleNavierStokesStepper(
grid=grid,
boundary_conditions=[bc_floor, bc_slip, bc_car],
collision_type="KBC" # Kinetic Boundary Condition
)
# Run Physics
f_0, f_1 = stepper(f_0, f_1, bc_mask, omega, step)
During the "Sleep Phase," the agent distills its neural weights into human-readable differential equations using genetic programming (PySR).
> [SCIENTIST] Waking up...
> [MEMORY] Reading trajectory buffer (Size: 80,000)
model = PySRRegressor(
binary_operators=['+', '*', '/', '-'],
unary_operators=['cos', 'exp', 'sin'],
model_selection="best"
)
> DISCOVERED LAW (Bernoulli):
> Reward = 20.0 - (1.0 / velocity)
Continuous-time control for continuous-time physics. The network adapts its internal clock speed ($\tau$) dynamically based on input turbulence.
class LiquidCell(nn.Module):
def forward(self, input, hidden, time_delta):
# Dynamic Time Constant
tau = torch.sigmoid(self.tau_learner(input))
# ODE Solve (Semi-Implicit)
d_hidden = -hidden / tau + self.synapse(input)
new_hidden = hidden + d_hidden * time_delta
return new_hidden
$State = (1 - \alpha)\Psi_{NN} + \alpha \Psi_{Symb}$
Equation 3.1 from core/brain.py
Active Inference Mechanism
Pure Neural Networks are fast but hallucinate. Pure Physics Solvers are rigorous but slow.
ATOM uses a Trust Gate ($\alpha$) to dynamically blend them. When the Symbolic
Scientist discovers a valid law (high confidence), $\alpha \to 1$, forcing the neural state to
collapse onto the physical manifold.
$\alpha \approx 0.0$. The agent runs on pure neural intuition to explore the state space.
$\alpha \to 0.98$. The system locks onto the inverse law ($1/P_{base}$), effectively becoming a PID controller derived from scratch.
Traditional solvers (JAX Oracle) provide ground truth data. ATOM provides Physical
Laws.
By enforcing Symplectic Manifolds, ATOM explores a multi-modal Pareto
Frontier—autonomously evolving
from
Linear Damping to Inverse Singularity Control.
*Benchmarks on Consumer Hardware, Ready to scale
Touch to interact • D2Q9 Lattice Boltzmann Solver • Running Locally (JavaScript)
"The computer is just a tool. The discovery is human."
- Computational
Anatomy Labs
In this showcase, ATOM demonstrated Strategic Plasticity. Instead of converging to a single solution, the agent independently discovered a Pareto Frontier of three distinct physical mechanisms—moving from reactive damping to preventative pressure maintenance.
Ablation Study (Control vs. Experiment)
| Method | Regime | Result |
|---|---|---|
| Standard PPO (Unconstrained) | Re=1000 | Gradient Collapse FAIL |
| Rabault et al. (2019) | Re=100 | ~8% Drag Reduction |
|
ATOM (Symplectic Gate)
|
Re=1000 | 41.3% Lift Stabilization |
Why this matters: Standard Deep RL fails to generalize in chaotic regimes ($Re \ge 1000$) due to non-stationary dynamics. ATOM succeeds by enforcing Symplectic Energy Constraints ($dH/dt \approx 0$).
Frequently Asked Questions
Not exactly. Standard PINNs use soft-loss constraints ($\mathcal{L}_{\text{physics}}$) which can still be violated. ATOM uses Hard Constraints via coordinate transformation (Helmholtz Decomposition) and Symplectic Integrators. Our architecture cannot represent a state that violates mass conservation, even before training begins.
We use a modified Genetic Programming approach (PySR) guided by a Transformer policy. During the "Sleep Phase," the agent replays high-reward trajectories from its Ring Buffer and attempts to fit parsimonious differential equations to the latent dynamics. These equations are then verified against the Ground Truth solver.
The Production Solver (Teacher) requires NVIDIA A100/H100 clusters for high-Reynolds turbulence ($Re > 10^6$). However, the Inference Agent (Student) is highly optimized and runs in real-time on consumer hardware (Apple M3/M4 or NVIDIA RTX 4090), enabling edge deployment.
We are not building another chatbot. We are building a true partner in the process of scientific discovery itself.
Standard Black-Box policies learn statistical correlations. ATOM learns physical causality. By combining differentiable physics with symbolic reasoning, the system doesn't just optimize rewards—it discovers the underlying laws that govern our reality.
Domain Transfer Validation
Proof of architecture: We swapped the solver kernel from D3Q27 (Fluids) to D2Q25 (Acoustics). The Neuro-Symbolic Agent adapted instantly, stabilizing a supersonic horizon without retraining the reasoning core.
"The acoustic black hole demo uses the exact same ATOM architecture that solves automotive CFD. This confirms Universal Differential Reasoning across discrete physics domains."
Public Beta Alpha 0.1
Democratizing Physical AI. In Q2 2026, we are releasing the ATOM Research Toolkit—giving the community the tools to be at the frontier of Physical AI.
Pure JAX implementation of Helmholtz-Fourier Layers. Project your gradients onto the solenoidal manifold with a single decorator.
A library of differentiable D2Q9, D3Q19, and D3Q27 lattice kernels. Built for GPU-accelerated inverse design.
Gradient-based optimization primitives pre-coupled with our Hamiltonian Integrators for aerodynamic shape optimization.
Engagement Paths
8-week proof-of-concept on your geometry. Validate speedup and accuracy against your existing CFD pipeline.
Joint research, co-publication, technology integration. For corporate R&D labs and academic institutions.
Pre-seed funding, strategic investment, or acquisition discussions. For VCs and corporate development teams.