Autonomous scientific computing

Describe the problem.
It runs the science.

SynapseX AI by SoftQuantus is building autonomous AI world models that accelerate scientific simulation, engineering optimization, and discovery across HPC and quantum computing.

Book a demoOpen SynapseX Chat
World-model loop live on this pageQuantum simulation live in ChatEnd-to-end autonomy in development
5steps of the loop running live on this page
1,536designs the model scores each round, in your browser
3engine capabilities live today
9engine capabilities in development
5steps of the loop running live on this page
1,536designs the model scores each round, in your browser
3engine capabilities live today
9engine capabilities in development
5steps of the loop running live on this page
1,536designs the model scores each round, in your browser
3engine capabilities live today
9engine capabilities in development
The shift

Not a question to an AI.
A problem, taken to a validated result.

01

You state the goal

A scientific or engineering problem in plain words: what to improve, what must hold, what counts as success.

02

SynapseX runs the study

It designs the experiment, runs the simulations, learns a world model from them, explores the design space and sends only the uncertain or promising cases back to the solver.

03

You get a checked result

The best candidates validated in the original solver, with figures, the model's error and a sealed record of every run.

In development The end-to-end loop is what we are building. The pieces that run today are marked on this page.

The loop, running

Simulation. World model.
Discovery.

The same loop at teaching scale, in your browser. A solver runs a few designs, a model learns from them and scores every design in the space, and the next solver runs go where the model expects the best result or knows the least.

01World-model loop
Running
Parameters
4 runs
κ 2.0
26 runs

The objective: deposit as fast as possible while the film stays uniform within the tolerance. Set exploration to 0 and the loop still finds a good design, but its model of the rest of the space stays wrong.

World model over temperature (→) and pressure (↑)
Best design and model error
Readout
Solver runs0/ 26
Designs scored by the model0
Model error, median—%
Best merit—nm/min
Best design—
Gap to scan optimum—%
Validation: model → solver—
Exhaustive scan1,536runs

Colour is the merit the model predicts; it fades where the model is unsure. The error and the gap are known only because this page also runs all 1,536 designs in the background. On a real problem that scan is the cost the loop avoids.

Computed in your browser. The solver is a reduced-order transport and reaction model of a wafer reactor, the same one as on the Simulations page; the world model is a Gaussian process over its two outputs, with the length scale chosen by marginal likelihood. In this model the best designs sit on the low-pressure edge of the space, and the loop is not told that. A demonstration of the loop, not a benchmark.

Running above, in your browser. The loop decides which designs to simulate; the exhaustive scan is there only so the page can print how close it got. A reduced-order model, not a sector world model.

Five tools

Five verbs.
One loop.

Everything the agent does in a study is one of these five calls. That is the whole interface.

simulate()

Run the physics

The solver is the source of truth. Today: quantum circuits, your own differential equations and short Python runs in SynapseX Chat. Sector-scale solvers on high-performance computing are in development.

Live at teaching scale
learn_world_model()

Learn from every run

Fit a model to what the solver returned, with an uncertainty on every prediction. The panel above fits a Gaussian process; neural operators and graph networks for full fields are in development.

In development
explore()

Score the whole space

Ask the model about every candidate design, not only the ones that were simulated, and find where it is unsure.

In development
optimize()

Choose what to run next

Spend the next solver runs where the predicted result is best or the model knows least. Bayesian optimisation with batch selection runs on this page.

Live on this page
validate()

Check in the solver

The best candidate goes back to the original solver before it is reported. The prediction and the solver result are printed side by side, and the record is sealed.

In development
Architecture

Agent, models, solvers,
and the machines under them.

One stack from the stated problem to the hardware. The agent decides what to simulate, the solvers compute it, the world models learn it, and QCOS chooses where each job runs.

Scientific agent

Agent live in Chat

Reads the problem, plans the study and explains the result.

  • Reasoning model
  • Experiment planner
  • Knowledge layer

Scientific compiler

In development

Turns a stated goal into parameters, constraints, metrics and a runnable study.

Classical simulation

Live at teaching scale

The source of truth.

  • Fluids and finite elements
  • Plasma
  • Molecular dynamics
  • Electromagnetics
  • Circuits

AI world model

In development

Learns the solver and scores the design space.

  • Neural operators
  • Physics-informed and graph networks
  • Transformers
  • Diffusion models
  • Gaussian processes

Quantum algorithms

Live on simulators

Where the mathematics justifies them.

  • Variational eigensolvers
  • Approximate optimisation
  • Amplitude estimation
  • Quantum machine learning

QCOS, the hybrid computing operating system

Live for quantum runs

Decides where each job runs, estimates before it spends and seals the record.

GPU

Model training and inference

HPC

The expensive solver runs

QPU

Selected quantum workloads

Quantum simulators are live; partner quantum processors are in early access. Dispatch of solver runs to high-performance computing is in development.

World-model engine

Not one giant physics model.
The right model for each problem.

Different physics needs different models. The engine is built to pick the family from the problem and to train it on the solver's own output. Live today means it runs now, on this page or in SynapseX Chat. In development means it is on the build list.

Live today3In development9

Fields and geometry

  • Differential equations and fluids
    Neural operators.
    In development
  • Three-dimensional meshes
    Graph neural operators.
    In development
  • Physical fields
    Convolutional, vision-transformer and operator networks.
    In development
  • Known governing equations
    Physics-informed networks and operators.
    In development
  • Geometry generation
    Diffusion and flow models.
    In development

Molecules and time

  • Molecular systems
    Equivariant graph networks and transformers.
    In development
  • Physical time series
    State-space models and transformers.
    In development

Search and uncertainty

  • Optimisation
    Bayesian optimisation. Running in the panel on this page.
    Live today
  • Exploration
    Active learning with batch selection. Running in the panel on this page.
    Live today
  • Uncertainty from a probabilistic model
    Gaussian process. Running in the panel on this page.
    Live today
  • Uncertainty from ensembles
    In development
  • Automatic choice of model family
    The engine picks the architecture from the problem.
    In development
Quantum, selectively

HPC does the heavy lifting.
Quantum enters where the mathematics justifies it.

AI reduces the number of simulations. High-performance computing runs the ones that remain. Quantum algorithms are used for electronic structure, for some combinatorial problems and, on future fault-tolerant machines, for amplitude estimation. We do not claim that quantum computers speed up fluid dynamics.

Where QCOS is designed to send each workloadIn development
Fluid dynamics
GPU and HPC
Molecular dynamics
GPU and HPC
Density-functional theory
HPC
Electronic structure
HPC, with variational quantum algorithms for selected systems
Combinatorial optimisation
Classical solvers, with quantum approximate optimisation where it fits
World-model inference
GPU
Scientific data engine

Every run is recorded.
Every record can teach a model.

A simulation that is thrown away after one figure is compute spent once. The data engine keeps what is needed to reproduce a run and to learn from it.

Recorded for every runIn development
  • Geometry
  • Parameters
  • Solver and version
  • Boundary conditions
  • Mesh
  • Results
  • Errors
  • Run time
  • Hardware
  • Accuracy against reference
  • Experimental result

Your data stays yours

A run enters a training set only when its owner authorises it. Public datasets and our own simulation campaigns come first.

A worked example

One sentence in.
A validated design out.

The first milestone is surrogate modelling for engineering: open-source fluid, finite-element and molecular-dynamics solvers and your own Python, driven by the loop above. What it has to show: less compute, a larger design space, a validated result.

“Find a heat-exchanger geometry that cuts pressure loss by 15 % while keeping the heat transfer.”

Target workflow
  1. 01Turn the goal into parameters, constraints and metrics.
  2. 02Choose the solver class: here, computational fluid dynamics with heat transfer.
  3. 03Generate a first set of geometries that covers the space.
  4. 04Send the expensive cases to high-performance computing through QCOS.
  5. 05Learn a world model from the results.
  6. 06Score the full design space with the model.
  7. 07Find the regions where the model is unsure.
  8. 08Send only those designs back to the solver.
  9. 09Update the model and repeat until the budget or the target is met.
  10. 10Optimise the candidates against the goal.
  11. 11Validate the best designs in the original solver.
  12. 12Deliver figures, geometry, a report and a sealed record of every run.
See also

Five solvers, live in your browser.

Fusion, a wafer reactor, atmospheric entry, a quantum wave packet and a design search, each solving its equations as you watch.

Simulations
See also

A simulation ends in a figure.

How SynapseX turns simulation output into figures that state their units, their source and what was reduced.

Scientific visualization
FAQ

World models,
answered plainly.

A model trained on the output of a physics solver, and where available on experimental data, that predicts what the solver would return for a design it has not run. It answers in milliseconds, so it can score a whole design space, and it reports how sure it is, so the expensive solver is spent only where the answer matters or the model is unsure.

You describe a scientific or engineering problem and the system designs the study, runs the simulations, learns a world model from them, explores the design space, validates the best candidates in the original solver and records how it got there. In SynapseX the end-to-end loop is in development. The pieces that run today are marked Live today on this page.

No. SynapseX is building a world-model engine that picks a model family to fit the problem: neural operators for fields governed by differential equations, graph operators for meshes, equivariant networks for molecules, Gaussian processes and ensembles where a calibrated uncertainty matters most. A model is trained per problem class and checked against the solver that produced its data.

The loop on this page runs in your browser: a reduced-order solver, a Gaussian-process world model, batch selection and validation. In SynapseX Chat you can run quantum circuit simulations, integrate your own differential equations and execute short Python runs. Sector-scale solvers, automatic model selection and high-performance-computing dispatch are in development.

We publish no speed-up figure until it has been measured against a named reference solver on a stated problem. What the loop is designed to show is this: less compute, a larger design space explored, and a result validated in the original solver.

You do not take its word. Every prediction carries an uncertainty, the designs it is least sure about go back to the solver, and the final candidates are validated in the original solver before they are reported. The record of each run is sealed, so the path from problem to result can be checked later.

Selectively. High-performance computing does today's heavy lifting and world models reduce the number of simulations. Quantum algorithms enter where the mathematics justifies it: electronic structure, some combinatorial optimisation problems and, on future fault-tolerant machines, amplitude estimation. We do not claim that quantum computers speed up fluid dynamics.

It stays yours. The scientific data engine records each run so that it can be reproduced and audited. A run enters a training set only when its owner authorises it.

Bring us
the study you cannot afford to run.

We are choosing design partners with an expensive solver and a large design space. Their cases decide what is built first.

Book a demoOpen SynapseX Chat

The panel on this page runs a reduced-order model in your browser and is a demonstration of the loop, not a benchmark. Capabilities marked In development are not available yet. No speed-up figure is published until it has been measured against a named reference solver.