PELAGIC SYSTEMS

REAL-TIME CONTROL

Real-time control
without compromise.

Optimization, sampling, estimation, and feedback — directly inside the experiment.

Explore the FPGA toolboxSee real experiments
Quantum control hardware against an ocean backdrop

01 / THE REAL-TIME TOOLBOX

More than control.
A scientific computing toolbox.

Optimization, estimation, machine learning, and more — running directly inside your quantum experiment.

Full-covariance CMA-ES

CMA-ES search on an illustrative objective landscape
Full-covariance CMA-ES

Incremental spline estimation

Incremental spline estimation from 21 measurements
Incremental spline estimation

Running z-score event detection

Running z-score event detection
Running z-score event detection

DBSCAN clustering

DBSCAN classification of readout IQ data
DBSCAN clustering

Least-squares matrix solve

LEAST SQUARES
x^=arg min⁡x∥Ax−b∥22\hat{x}=\operatorname*{arg\,min}_{x}\lVert Ax-b\rVert_2^2
MATRIX SOLVER · FPGA

Adaptive sampling

Adaptive Voronoi sampling of a response landscape
Adaptive Voronoi sampling

Streaming histogram

Streaming histogram of acquired measurements
Streaming histogram

Three-point T₁ estimation

Three-point T₁ estimation — placeholder graphic
Three-point T₁ estimation — placeholder figure.

02 / FAMILIAR SYNTAX

Powerful algorithms.
Familiar syntax.

Take the scientific tools you know into the experiment. Start with a familiar interface.

SciPy · CPU
PYTHON
from scipy.signal import find_peaks

peaks, prop = find_peaks(signal, height=0.0, distance=50)
SciPy logo
SciPy CPU peak detection: red markers identify peaks above the zero-height threshold in a measured trace
CPU peak finding using SciPy.
Real timeRunning on FPGA
Pelagic · FPGA
PYTHON
from pelagic.fpga.signal import find_peaks

peaks, prop = find_peaks(signal, height=0.0, distance=50)
Pelagic logo
Pelagic FPGA peak detection: green markers identify the same peaks above the zero-height threshold
FPGA peak finding using Pelagic.

The same peak-finding call, with only the import changed.

03 / FULL EXAMPLE

Let the experiment find the answer.

Minimize readout error with Nelder–Mead. Each measurement guides the next frequency offset and amplitude, tracing a path toward an optimized operating point.

Nelder–Mead readout optimization: simplex trajectory over frequency offset and amplitude, with readout-error convergence below
Nelder–Mead readout optimization: parameter trajectory across frequency offset and amplitude (top), and readout-error convergence over successive iterations (bottom).
Running on FPGA
Nelder–Mead readout optimization
PYTHON
from pelagic.fpga.optimize import minimize

def objective(parameters):
    frequency_offset, amplitude = parameters
    # Experiment-specific readout-error acquisition.
    return measure_readout_error(frequency_offset, amplitude)

# x0: (frequency offset, amplitude).
result = minimize(
    objective,
    x0=initial_readout_parameters,
    method="Nelder-Mead",
)

04 / RETHINK THE EXPERIMENT

New control. New experiments.

When analysis can happen inside the experiment, the experiment itself can change. Design around what you learn, instead of a fixed list of measurements.

Real-time calibration overview showing readout optimization, qubit frequency calibration, pulse amplitude calibration, and gate fidelity estimation
Real-time calibration overview: readout, qubit frequency, pulse amplitude, and gate fidelity.

Choose the next measurement.

Use the response you just measured to decide where to probe next, rather than committing to an entire sweep in advance.

Measure until you know enough.

Make your stopping rule part of the experiment. Continue collecting information where uncertainty matters.

Adapt while the experiment runs.

Estimate a parameter, change a delay, or select a new branch inside the same control sequence.

05 / CLOSE THE LOOP

Combine experiments. Reveal new physics.

Combine five real-time calibration experiments into one on-FPGA workflow. Keeping readout, drive, and coherence measurements together lets you explore a changing quantum device on its own timescale.

~34 msper complete five-stage cycle

Running on FPGA
  1. 01

    Readout frequency

    Optimize the readout setting.

  2. 02

    IQ threshold

    Set the state-discrimination boundary.

  3. 03

    Drive frequency

    Track the qubit resonance.

  4. 04

    Dephasing rate Γ₂

    Estimate the loss of coherence.

  5. 05

    Relaxation rate Γ₁

    Estimate energy relaxation.

Approximately 34 ms for the illustrated five-stage cycle, not the entire frequency sweep.

Step the qubit frequency. Repeat the cycle.

Repeat the combined workflow across qubit frequency and over time to resolve two-level-system (TLS) dynamics. The measured relaxation-rate map below reveals how loss features move and fluctuate while the device is recalibrated.

TLS spectroscopy: qubit relaxation rate Gamma1 across frequency and wall-clock time, with two zoomed views and a recalibration sequence
TLS spectroscopy: relaxation rate Γ₁ across qubit frequency and elapsed time, with zoomed views. Supplied experimental figure.
View the illustrative workflow
TLS tracking with recalibration
PYTHON
stm = StreamManager()
axt = stm.axis_tracker

with program() as prog:
    i, flux = declare(int), declare(fixed)  # Iteration, flux point.

    with axt.add_axis(for_(i, 0, i < n_iterations, i + 1), name="iteration"):
        # (1) Reset initial parameters.
        set_initial_parameters(qubit)

        with axt.add_axis(for_each_(flux, flux_points), name="flux_point", unit="V"):
            # (2) Set flux point.
            qubit.z.set_dc_offset(flux)

            # (3) Calibrate the qubit at the flux point.
            qubit.calibrate_readout_frequency(stm=stm, apply_correction=True)
            qubit.calibrate_iq_threshold(stm=stm, apply_correction=True)
            qubit.calibrate_drive_frequency(stm=stm, apply_correction=True)

            # (4) Estimate decoherence times.
            qubit.estimate_t2_echo(stm=stm)
            qubit.estimate_t1(stm=stm)

    with stream_processing():
        stm.process()  # Automatically reshape data into an xarray.Dataset.

06 / PROVEN ON QUANTUM HARDWARE

Calibration in milliseconds.

On-FPGA acquisition and analysis keep calibration decisions close to the experiment. Demonstrated on a superconducting quantum processor.

Faster than a blink of an eye.

9.8 ms T₁ estimation.

From the first experimental shot to an estimate available on the controller.

Reported T₁ result

Limited by pulse sequence, not by analysis.

Pulse execution, acquisition, and reset dominate the reported timing budget.

Running on FPGA
Experimental calibration times and the time spent on pulse sequences, measurement, reset, analysis, and communication for on-FPGA execution versus host offloading
Experimental timescales and time allocation for on-FPGA execution versus host offloading.
Read the calibration research

PELAGIC REAL-TIME

What will you build in real time?

Bring your next experiment into the control loop. Let’s talk about what you want to measure, learn, and change.

Talk to us