"Quantum computing will supercharge AI" is the single most repeated claim in quantum marketing. It is also the claim with the weakest evidence behind it.
This isn't a takedown. Quantum machine learning is a real research area with real results and a handful of genuinely interesting open directions. But the gap between what QML is often said to do and what has actually been demonstrated is wider than in almost any other corner of the field. If you're deciding whether to invest time here, you deserve the honest version.
So: what QML actually is, what the evidence shows, and what's still worth watching.
What quantum machine learning actually means
The term covers several quite different things that get blurred together.
Variational circuits as trainable models. This is what most people building QML today are doing. You write a parameterized quantum circuit — a variational circuit — feed data in, measure an output, and use a classical optimizer to adjust the parameters until the output matches your labels. Structurally it's the same hybrid algorithm pattern as VQE, just with a loss function instead of an energy. The circuit is the model; the rotation angles are the weights.
Quantum kernels. Instead of training a quantum model directly, you use the quantum computer only to compute similarities between data points — encode two inputs into quantum states and measure their overlap. That similarity matrix then feeds an entirely classical support vector machine. The quantum device does one narrow job, which makes this approach much more robust to noise than end-to-end variational training.
Data encoding. Both approaches need classical numbers turned into quantum states, and this choice matters more than anything else in the pipeline. Angle encoding maps each feature to a rotation angle — simple, but it needs one qubit per feature. Amplitude encoding packs 2ⁿ values into n qubits, which sounds magical until you look at the circuit depth required to prepare that state.
Quantum-accelerated linear algebra. The original, most theoretically ambitious branch: algorithms like HHL for solving linear systems with exponential speedups on paper. This is where the big speedup numbers in QML pitches come from — and where the caveats bite hardest.
The data-loading bottleneck
The Biamonte et al. review — still the standard reference for the field — is unusually direct about the central problem, and it applies to that fourth category above.
Many quantum ML algorithms with proven exponential speedups assume your data is already sitting in quantum RAM, in a convenient superposition, ready to be operated on. That's a big assumption. If you have to load N classical data points into a quantum state, and loading takes time proportional to N, then an algorithm that runs in log(N) time once loaded still costs you O(N) overall. The speedup evaporates in the preprocessing step.
This isn't a hardware engineering problem that better devices will fix. It's structural. And it got worse: over the past decade, a series of "dequantization" results showed that several proposed quantum ML speedups had classical algorithms achieving comparable scaling once you granted the classical side similar sampling access to the data. The quantum advantage in those cases turned out to be an artifact of comparing a quantum algorithm with quantum data access against a classical algorithm without equivalent access.
The practical rule: be suspicious of any quantum ML speedup claim that doesn't account for how the data got in.
Barren plateaus
The variational approach — the one most people actually build with — has its own structural obstacle, and it's the one described in McClean et al..
Training a variational model means computing gradients and stepping downhill. McClean and colleagues showed that for randomly initialized circuits, the variance of the gradient shrinks exponentially as you add qubits. The optimization landscape flattens into a featureless plain — a barren plateau — where every direction looks the same.
Why this is fatal rather than merely annoying: gradients on quantum hardware are estimated from measurement statistics, so they come with shot noise. Once the true gradient is smaller than your sampling error, you need exponentially many shots just to tell which way is down. At a few dozen qubits with a generic ansatz, the training signal is gone.
Mitigations exist and are actively researched — structured problem-informed ansätze, layerwise training, smart initialization, local rather than global cost functions. None is a general solution. Any claim that a variational quantum model scales to useful problem sizes has to explain how it escapes this, and most don't.
The 2026 head-to-head comparison
Theoretical caveats are one thing. The more useful question is what happens when someone actually runs the models side by side, and that's rarer than you'd expect — QML papers usually benchmark against other QML papers.
Yu et al. (2026) did the like-for-like version: seven matched quantum/classical model pairs, spanning both supervised learning and reinforcement learning, run on the same problems with the comparison held as fair as they could make it.
The quantum models lost. Not on one axis — on three:
- Prediction performance. Classical baselines were more accurate.
- Policy stability. In the reinforcement learning tasks, the quantum models produced less stable policies.
- Training time. The quantum models were slower to train.
That last one deserves emphasis, because "quantum is slower" is the opposite of the entire pitch. Circuit execution overhead, the shot counts needed for gradient estimation, and the classical-quantum round trips add up.
One careful negative result doesn't close a research field. But it's the right kind of evidence, and it points the same direction as the theory. As of mid-2026, "quantum will make AI faster" is not supported by the evidence. If someone tells you otherwise, ask them for the head-to-head benchmark.
Try it yourself
The best way to develop intuition here is to build one. This is a complete variational quantum classifier in PennyLane — angle encoding, a trainable entangling ansatz, and a gradient-descent loop:
import pennylane as qml
from pennylane import numpy as np
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
n_qubits = 2
n_layers = 3
dev = qml.device("default.qubit", wires=n_qubits)
@qml.qnode(dev)
def circuit(weights, x):
# Data encoding: each feature becomes a rotation angle
qml.AngleEmbedding(x, wires=range(n_qubits), rotation="Y")
# Trainable ansatz: rotations plus entangling CNOTs
qml.BasicEntanglerLayers(weights, wires=range(n_qubits))
return qml.expval(qml.PauliZ(0))
def variational_classifier(weights, bias, x):
return circuit(weights, x) + bias
def square_loss(labels, preds):
return np.mean((labels - qml.math.stack(preds)) ** 2)
def cost(weights, bias, X, Y):
preds = [variational_classifier(weights, bias, x) for x in X]
return square_loss(Y, preds)
# Two-moons dataset, labels mapped to -1 / +1 to match <Z>
X, y = make_moons(n_samples=200, noise=0.15, random_state=42)
y = 2 * y - 1
X_train, X_test, y_train, y_test = train_test_split(
X, y, test_size=0.3, random_state=42
)
shape = qml.BasicEntanglerLayers.shape(n_layers=n_layers, n_wires=n_qubits)
rng = np.random.default_rng(42)
weights = np.array(rng.normal(0, 0.1, shape), requires_grad=True)
bias = np.array(0.0, requires_grad=True)
opt = qml.AdamOptimizer(stepsize=0.1)
batch_size = 20
for step in range(60):
idx = np.random.randint(0, len(X_train), (batch_size,))
X_batch, y_batch = X_train[idx], y_train[idx]
weights, bias, _, _ = opt.step(cost, weights, bias, X_batch, y_batch)
if step % 15 == 0:
preds = [np.sign(variational_classifier(weights, bias, x)) for x in X_train]
acc = np.mean(np.array(preds) == y_train)
print(f"Step {step:2d} | cost {cost(weights, bias, X_train, y_train):.4f} | acc {acc:.3f}")
test_preds = [np.sign(variational_classifier(weights, bias, x)) for x in X_test]
print(f"\nTest accuracy: {np.mean(np.array(test_preds) == y_test):.3f}")
Running it (PennyLane 0.45, default.qubit) gives:
Step 0 | cost 1.6158 | acc 0.336
Step 15 | cost 0.6775 | acc 0.764
Step 30 | cost 0.6466 | acc 0.779
Step 45 | cost 0.6372 | acc 0.850
Test accuracy: 0.817
So it trains, and 82% on two moons is respectable. It is also worth noting what it doesn't do: an RBF-kernel SVM from scikit-learn scores 0.983 on the identical split, and fits in under a millisecond on your laptop. That comparison isn't a criticism of the code — it's the honest baseline that a lot of QML demos quietly omit.
Try scaling it. Push n_qubits up, widen the ansatz, and watch the gradients shrink. You can reproduce the barren-plateau effect on a simulator in an afternoon, which is a far better education than reading about it.
What's actually promising
None of the above means QML is a dead end. Three directions look genuinely worth pursuing, and they share a feature: they avoid the problems above rather than hoping to power through them.
Quantum data instead of classical data. The data-loading bottleneck exists because we're forcing classical numbers into quantum states. If your data is already quantum — states produced by a physics experiment, molecular ground states, outputs of a quantum sensor — there's nothing to load. Learning tasks on quantum data have the cleanest theoretical case for advantage, and unlike most QML claims, the argument survives scrutiny. This overlaps heavily with where quantum computing is delivering results generally: physics and chemistry, not business analytics. Our use cases page covers the distinction.
Quantum kernels for structured data. Because the quantum device only computes similarities, kernel methods sidestep barren plateaus entirely — there's no deep variational landscape to descend. For data with structure that maps naturally onto a quantum feature space (group-theoretic structure, certain periodic problems), there are constructed examples with provable separations. The honest caveat is that these are usually engineered problems rather than datasets anyone had lying around.
Noise filtering. Notably, the Yu et al. comparison that found quantum models losing on every headline metric also identified noise filtering and false-positive control as areas where quantum approaches still looked promising. That's a narrow, specific niche — and narrow, specific niches are how technologies actually gain footholds.
Where this leaves you
If you're learning quantum computing, QML is still worth your time — just for the right reasons. The techniques transfer. Data encoding, ansatz design, gradient estimation, and the hybrid loop are the same skills that VQE and QAOA need, and those have clearer near-term paths. Learning QML makes you better at variational quantum computing generally.
What to avoid is building a business case on a speedup that hasn't been demonstrated. The same discipline applies here as in benchmarking hardware claims: ask what the classical baseline was, ask whether data loading was counted, ask how many qubits the result scales to.
Preskill's NISQ paper set the tone for this kind of honesty about near-term devices, and it has aged well precisely because it under-promised. QML would benefit from the same posture.
The field is more interesting when you stop needing it to be revolutionary. Start with the PennyLane SDK guide, keep the glossary open, and run the experiments yourself — the evidence is more useful than the pitch.