Project Showcase: Quantum Systemic Oracle

The Quantum Systemic Oracle takes a quantum computation and turns it into something a smart contract can read: a single daily number for how stressed the financial system looks, published on-chain for anyone to consume.

Its framing, in the project's own words, is quantum compute as an on-chain primitive. A portfolio-optimization circuit runs on IonQ, its result is distilled into a systemic risk index in basis points, and that index is pushed to a Chainlink-shaped oracle that other contracts can call like any other price feed.

It is a Spring 2026 challenge project from Jamie Dominguez, who does not come from quantum at all. He spent more than a decade in enterprise data governance at a global bank, and used the challenge to find out how far a domain expert with modern AI tooling could actually get on real quantum hardware.

I came from technology and data governance. I became interested in quantum having long followed tech trends, including using GPUs to speed up data queries, and I believe we'll see similar advancements with quantum technology.

From data governance to a QPU

Jamie has spent his career close to large financial data, the reference tables and integrations that keep a bank's systems agreeing with each other. Quantum was a trend he watched from that vantage point, in the same way he had watched GPUs go from a graphics curiosity to the backbone of fast data queries. The challenge was the first time he ran his own jobs rather than reading about other people's.

This was my first QPU job and Qiskit run. I learned it's much easier to get started now than ever before.

That starting point shapes the whole project. It is not a research-grade quantum-finance paper, and it does not pretend to be. It is a working end-to-end pipeline built by someone who knows financial systems deeply and treated the quantum step as one component to wire in, not a mountain to summit first.

A risk score as a primitive

The core idea is to make a quantum computation legible to the rest of the software world. Most quantum results live in notebooks. Jamie wanted his to live somewhere other programs could act on it automatically, so he published it where automated systems already read their inputs: on-chain.

The idea of a quantum risk score being on-chain came from thinking about how quantum compute could be leveraged in a wider ecosystem. Blockchain makes sense as a way to potentially contribute to agentic smart contracts in the future, blending quantum, AI, and blockchain.

Concretely, the system is three layers stacked end to end:

• A Python engine pulls live market signals, prediction-market odds, funding rates, volatility, and fear indices, and turns them into the inputs for an optimization problem.
• A quantum step runs that optimization on IonQ and blends the result with eight market signals into a single systemic risk index, scaled in basis points from 0 to 10,000.
• An on-chain oracle publishes the index to Ethereum through a Chainlink-shaped AggregatorV3 interface, so any contract can read it with the same call it would use for a price feed.

Once it is on-chain, the score stops being a chart and becomes a building block. A lending protocol could widen collateral ratios when the index spikes, a vault could trigger deleveraging, a prediction market could resolve against it. That is what Jamie means by a primitive: not a dashboard people look at, but a number other code is built on.

Inside the circuit

The quantum step is a QAOA portfolio optimization, the same family of algorithm you would reach for to pick a basket of assets under competing constraints. Jamie chose finance deliberately, because it is one of the areas where quantum methods are already showing early promise.

Given that quantum advancements are showing promise for financial applications like portfolio optimization, it was a perfect use case to blend my interests.

The circuit encodes eight candidate assets as eight decision qubits, plus six more that carry the global market state, the regime, volatility stress, DeFi stress, and stablecoin dominance. A neat piece of engineering keeps it lean: those market witnesses fold into single-qubit rotations rather than expensive two-qubit gates, so the circuit grows by exactly one qubit per asset, not per signal. On Qollab, the circuit-side preview runs on hardware exactly as written:

# The quantum step of a daily on-chain crypto risk oracle.
# 'backend' is pre-created from the "Select QPU" dropdown below.
from qiskit import QuantumCircuit, transpile
from qiskit.providers.jobstatus import JobStatus
import time

N_ASSETS, N_WITNESS, SHOTS = 8, 6, 1000

def apply_cost_layer(qc, gamma, h, J_pairs, n):
    # ZZ couplings = the portfolio cost Hamiltonian
    for i in range(n):
        qc.rz(2.0 * gamma * h[i], i)
    for p in J_pairs:
        qc.cx(p["i"], p["j"])
        qc.rz(2.0 * gamma * p["value"], p["j"])?Cost layer. Each ZZ coupling encodes a pairwise term of the portfolio Hamiltonian: Markowitz risk, funding crowding, and prediction-market sentiment.        qc.cx(p["i"], p["j"])

def build_circuit(gammas, betas, h, J_pairs, snapshot):
    n, n_total = N_ASSETS, N_ASSETS + N_WITNESS   # 8 assets + 6 witnesses
    qc = QuantumCircuit(n_total, n_total)
    for i in range(n):
        qc.h(i)?Superposition. A Hadamard on each asset qubit opens an even superposition over all 256 candidate portfolios: QAOA's starting point.
    stressed = snapshot["regime"]["regime"] == "risk_off"
    def fold(theta, p):                       # witness -> asset soft bias
        for i in range(n):
            qc.ry(theta * (1.0 - 2.0 * p) / 2.0, i)
    fold(-0.10, 1.0 if stressed else 0.0)?Six global market witnesses (regime, vol-stress, DeFi-stress, stablecoin dominance) fold into 1-qubit ry rotations, so a risk-off market tilts every asset defensive without extra two-qubit gates.
    for layer in range(len(gammas)):
        apply_cost_layer(qc, gammas[layer], h, J_pairs, n)
        for i in range(n):
            qc.rx(2.0 * betas[layer], i)?Mixer. The RX layer nudges the state toward neighbouring portfolios so the optimizer can escape a single bitstring.    qc.measure(range(n_total), range(n_total))
    return qc

qc = build_circuit(gammas, betas, ising_h, ising_J_pairs, SNAPSHOT)
job = backend.run(transpile(qc, backend), shots=SHOTS)?Submits one shot batch to the selected IonQ backend through Qollab. The sampled portfolios become this run's qaoa_solution_quality component of the risk index.while job.status() is not JobStatus.DONE:
    time.sleep(2)
counts = job.result().get_counts()   # sampled portfolios -> risk score (BPS)

The snapshot baked into the gallery version is frozen on a single day so it runs without any network calls, but the full pipeline in the repo fetches fresh market data daily and reruns the whole chain.

Built with AI, on real hardware

Jamie is candid that he did not write every line of Qiskit and Solidity from memory. He treated modern AI coding tools as the thing that closed the gap between his domain knowledge and the unfamiliar quantum and blockchain stacks, and he is enthusiastic about it as a way in.

It was enjoyable leveraging Cursor and the latest LLMs to create what was made. I'd encourage everyone to do so, it's the best way to learn first hand.

His practical advice for anyone wanting to follow the same path is concrete: set up MCP servers and lean on the basic skills they expose to start building straight away. The point is not to outsource the understanding, but to get a working loop going fast enough that you actually learn by running things, which is exactly how he got from never having touched Qiskit to submitting jobs on IonQ.

Where it's headed

The current oracle is a deliberately bounded prototype: eight assets, a frozen snapshot in the gallery, and publication confined to a testnet. What Jamie is watching is the hardware curve, because the use cases he is interested in open up as the machines grow.

I enjoyed running my first QPU jobs. I'll continue my learning path and look forward to running additional experiments as logical qubits scale, since that will keep enabling new use cases.

The architecture is built to grow with that curve. Because each asset adds exactly one qubit, widening the basket is a matter of appending to the asset universe and letting the circuit width, budget, and readout adapt. The longer arc he points at, agentic smart contracts that blend quantum, AI, and blockchain, is speculative by his own admission, but the oracle is a small, working first step in that direction.

Make it yours

The whole pipeline is open and forkable, from the circuit-side preview on Qollab to the live-data engine and the on-chain publisher on GitHub. If you want to go all the way to publishing your own score, Jamie has a tip for getting unstuck on the blockchain side.

I'd suggest others try getting testnet Chainlink and ETH tokens to test and publish their own smart contracts.