A model-free, retained-state runtime between your application and your hardware. It turns each measurement into the next configuration — so your existing control and optimization loops run tighter, at higher dimension, on fewer measurements, under more drift.
On a fresh weighted max-cut instance under a tight shot budget, the runtime reaches a usable solution while a gradient estimator is still warming up. Rendered live on a new random instance each visit — not a recording.
Stateful Wave Computing holds the configuration as state and advances it directly from the measured residual — the loop is converging from the first round rather than warming up. It sits as a thin middleware layer between the application or model that sets the objective and the wave substrate that realizes it: perception and learning stay where they are, the physics stays where it is, and the runtime is the adaptive control plane in between.
Most loops are not limited by the problem — they are limited by the cost of the loop around it. Classical control needs a model and many measurements; classical search needs time. So loops run conservatively. The runtime relaxes the binding constraint: one measurement per round, no model, converging from the first — so you can push a loop you already run into a harder regime than its current control allows:
If your task has a writable control and a measurable output, the runtime can run it harder — not a new class of problem, but more from the loops and devices you already have. It declines, by design, where a classical method already wins: when measurements and time are abundant, or when the objective lives in correlations the marginals cannot see.
The same direction holds across both modes, by two distinct mechanisms. In regulation, the measurement-efficiency advantage over gradient methods grows linearly and without bound — one measurement per update where finite-difference needs n+1. In optimization under a starved budget, where a classical solver has too few evaluations to search and stalls, the runtime keeps improving as the problem grows: in benchmarks it overtakes simulated annealing past a crossover and the margin widens with dimension. Both are established against fairly-tuned baselines, with hardware validation the active next step — the direction is consistent and it points somewhere new.
These are the conditions you push a loop into to get the advantage. The runtime replaces gradient estimation with a residual-feedback update and carries state across related problems — which changes the outcome in three places, and the client tells you honestly when you’re outside them.
One measurement per round, no model, no per-device tuning — tracking 3 to 10 times tighter than finite-difference and SPSA gradient methods, which cannot assemble a step before the target drifts away.
When there is no time for a classical solver to converge, the runtime returns a usable solution first — and under a fixed deadline it overtakes sequential search as the problem grows, the margin widening with dimension.
Retained configuration warm-starts each related problem from the previous physical trajectory — a re-convergence advantage that grows with relatedness and vanishes, correctly, when tasks are unrelated.
You hand the runtime a measured statistic each round; it returns the next configuration. During the free evaluation the residual update law runs server-side on our endpoint — you receive results and next-configs, never the method. With a paid license you can also run the runtime offline inside your own infrastructure — air-gapped, on-device, or wherever a network hop per round is too slow. Same loop, your environment.
The runtime needs one thing: read and write access to a parametric (wave) plant — a writable configuration and a response that varies smoothly with it. It is otherwise indifferent to the substrate. These are the wedges we are taking it into first.
Hold an MZI mesh locked under thermal drift and crosstalk at one measurement per round — and, for diagonal / QUBO-type objectives, drive the mesh itself toward a good configuration under a tight measurement deadline. Model-free, no per-chip tuning.
lead applicationKeep single-rotation observables — gate angles, readout points — locked to setpoint as the device drifts, one measurement per round. A retained-state control layer, not a variational optimizer (see scope below).
in developmentGPR, phased-array ultrasound, optical inspection, RF front-ends — any loop where each measurement is expensive and the operating point drifts. Recover a usable setting from few reads.
early accessThe runtime wins in a specific regime and we are explicit about its edges. Results are established in controlled benchmarks against fairly-tuned baselines; physical validation on photonic hardware is the active next step.
Drift-robust regulation and tracking, 3–10× tighter than tuned PI at one measurement per round. Retained-state memory across related tasks — an advantage that scales with relatedness and disappears when tasks are unrelated. Diagonal and QUBO-class optimization that returns a usable solution under tight deadlines — and overtakes sequential search at scale, where the deadline starves it. Self-calibration that keeps the loop stable on sign-varying plants.
The same behavior on a physical photonic mesh: phase stabilization under thermal drift, the mesh acting as a deadline-beating optimizer, and the retained-state memory signature. The protocol is built and portable; a hardware pilot is the decisive validation step.
Variational quantum energy minimization (VQE / QAOA), and objectives dominated by dense cross-correlations. Marginal feedback cannot resolve an objective that lives in correlations — so we do not claim it. The runtime is a regulation, calibration, and diagonal-objective engine, not a general variational optimizer.
Within its envelope the runtime reaches a usable solution in roughly n1.3 measurement rounds — sub-quadratic, where sequential digital search needs O(n²) work for comparable quality. An opt-in score-weighted estimator pushes the total-measurement cost lower still, to about n1.2 on structured problems in benchmarks. Under a fixed deadline that gap becomes a crossover: past a certain size the runtime overtakes classical search, and it widens with every increase in dimension. The projections below follow from that scaling behaviour, observed in benchmarks.
At a fixed quality target, the decisions-per-second advantage over digital search grows linearly with size — roughly 60× at n=16, 240× at n=64, and near 1000× at n=256. The larger the inner-loop problem, the wider the margin.
Under a fixed deadline, sequential search saturates at small problem sizes (its reach grows only as √D). The runtime’s reach grows linearly, putting problems two orders of magnitude larger within the same time budget — before any hardware-parallelism benefit.
The runtime is model-free and self-calibrating, eliminating the per-device control tuning that fixed-gain loops require and re-require as hardware drifts — a recurring engineering line item across a deployed fleet, removed.
Projections derived from the measured n1.3 convergence scaling. The per-operation timing ratio between an optical measurement and a digital evaluation is the one hardware-dependent factor; the algorithmic advantage holds even when that ratio is one.
Gradient estimators spend their first measurements approximating a descent direction. The runtime converts each measurement’s residual directly into the next configuration, so the earliest rounds already move toward the optimum. Below the budget crossover this is a decisive lead; above it, SPSA converges and the client returns DECLINE.
No rebuild, no migration. Keep your plant, your instruments, your data pipeline — add one client call inside your existing loop and the runtime returns the next configuration each round. The same interface drives a photonic mesh, an RF front-end, or a lab instrument; only the measurement function changes.
Occasional and technical — new results as they clear our pre-registration bar, and pilot slots as they open. No marketing cadence. Unsubscribe anytime.
Get a key, add the client to your loop in one line, and run it on your own workload for 90 days. Only a configuration vector and a scalar score cross the wire — your measurements stay with you. The number you get is yours, on your problem.