Quantum machine learning — the real positions in 2026
Quantum machine learning has spent five years caught between two camps: the people who think it's already out-performing classical ML, and the people who think it's a category error. Both are wrong. The honest position in 2026 is narrower and more useful — there are specific structures, on specific hardware, where a parameterised quantum circuit does something a classical neural network cannot easily replicate, and there are far more places where it does worse. If you're building toward Ireland Quantum 100's first customer cohort, the job right now is knowing which is which.
What QML actually is, stripped of the marketing
Quantum machine learning, in the near-term superconducting-transmon era, almost always means one of three things. First, a variational quantum circuit — a fixed-shape circuit with tuneable rotation angles, trained by a classical optimiser sitting outside the fridge. Second, a quantum kernel method — using the quantum device to compute inner products in a Hilbert space that's hard to evaluate classically, then handing the resulting kernel matrix to a perfectly ordinary support vector machine. Third, a quantum neural network, which is mostly a rebrand of the first category with layer-like structure imposed on the ansatz.
None of these are quantum versions of deep learning. They share almost no architecture with a transformer. The parameter counts are tiny — on a 100-qubit machine with realistic two-qubit gate budgets, you're training maybe a few hundred to a few thousand parameters, not a few billion. That isn't a flaw to be solved; it's the regime. The interesting question is what kinds of problems benefit from a model that small with that particular inductive bias.
The hardware reality on a 100-qubit transmon machine
If you're going to do QML on superconducting hardware, you need to be honest about what the device looks like. Ireland Quantum 100 is a heavy-hex topology of fixed-frequency transmons in a dilution refrigerator running below 15 mK. Single-qubit gates are fast and clean. Two-qubit gates — the cross-resonance or echoed-cross-resonance gates that actually entangle anything — are an order of magnitude slower and an order of magnitude noisier. Coherence times are measured in tens to low hundreds of microseconds depending on the qubit and the day.
This matters for QML because every layer of your ansatz that includes a two-qubit gate is paying a real noise tax. A 20-layer "quantum neural network" on raw hardware, without error mitigation, is a noise generator. You're not training a model; you're training a probability distribution over noise channels.
So the real near-term quantum ML circuits are shallow, structured, and chosen so the entangling pattern matches the physical connectivity. If your ansatz needs all-to-all entanglement, you're paying SWAP gate overhead that will eat your signal before training even starts. The usable region of design space is narrower than most QML papers admit.
Where QML plausibly beats classical, and where it doesn't
Three honest categories.
Probably useful, near-term: problems where the data itself is quantum. Classifying phases of matter from simulated or measured quantum states. Learning representations of molecular Hamiltonians for downstream variational eigensolver work. Generative models over quantum states for materials screening. Here the quantum device isn't competing with a GPU; it's the natural representation, and loading the data classically is the expensive step you avoid.
Open question, possibly useful: kernel methods on highly structured classical data — particularly graph-structured data with combinatorial features, or sequence data with periodic structure that maps cleanly to quantum feature maps. There's theoretical evidence the kernel can be hard to evaluate classically. There's almost no evidence the resulting classifier generalises better. Worth running. Don't bet a product on it yet.
Almost certainly not useful, near-term: image classification, large-scale natural language, recommender systems, anything with millions of training samples and high-dimensional dense features. The data loading bottleneck alone — encoding a classical vector into amplitudes of a quantum state — will eat any speedup you might dream of. The famous amplitude encoding trick costs you the speedup it promises the moment you account for state preparation.
If a vendor is showing you QML benchmarks on MNIST, they are either being polite to a journal reviewer or selling you something. MNIST is not where this technology earns its keep.
Barren plateaus and why most QNN papers age badly
The structural problem in quantum neural network training is the barren plateau. As you increase the number of qubits and the depth of a generic randomly-initialised ansatz, the gradient of your loss function with respect to the parameters becomes exponentially small almost everywhere. Your classical optimiser sees a flat landscape and can't move. This isn't a hardware noise issue — it's a property of how high-dimensional Hilbert spaces concentrate measure.
The mitigations are real and partial. Using problem-inspired ansätze rather than hardware-efficient generic ones — say, the Hamiltonian Variational Ansatz for chemistry, or equivariant circuits that respect the symmetries of your data. Layer-wise training. Smart initialisation, often using shallow circuits whose gradients are known to be non-vanishing. Local cost functions instead of global ones, since global observables on a many-qubit system are the worst-case scenario for plateaus.
What you should not do is take a generic 12-layer hardware-efficient ansatz on 50 qubits, initialise the angles uniformly at random, and expect Adam to find anything. That's the configuration most QML tutorials still teach. It will produce a paper. It will not produce a model.
The software stack you'll actually use
Tooling has consolidated. Three frameworks cover almost everything practical: Qiskit for circuit construction and IBM-style hardware backends, PennyLane for differentiable programming and the cleanest hybrid classical/quantum gradient interface, and Cirq where you need fine control over pulse-level scheduling. OpenQASM 3 is the lingua franca for circuit serialisation between them.
For QML specifically, PennyLane has the strongest ergonomics — its qml.qnn interfaces let you drop a quantum layer into PyTorch or Keras and the gradients flow through the parameter-shift rule automatically. That's not magic; the parameter-shift rule is exact for the Pauli-rotation gates that make up most ansätze, so you genuinely get true gradients, not finite-difference approximations. It does cost you two circuit evaluations per parameter per gradient step, which is the bill you pay for honesty.
Error mitigation belongs in the same stack. Zero-noise extrapolation, probabilistic error cancellation, and readout-error mitigation are the techniques that turn a noisy 100-qubit device into something a QML circuit can actually train on without surface-code level error correction. They cost you shots — sometimes orders of magnitude more shots — but they're what makes the difference between a result and a noise floor. Anyone doing serious near-term quantum ML on real hardware is doing mitigation; the papers that don't mention it are running on simulators.
Climate workloads as the QML proving ground
The reason Ireland Quantum 100 is dedicating its first cohort to climate problems isn't sentiment — it's that the climate-relevant chemistry workloads sit exactly where near-term QML has its strongest theoretical case. Learning compact representations of catalyst electronic structures for carbon capture. Variational eigensolver work on small but accurate models of photovoltaic absorbers. Generative models over candidate battery electrolyte molecules, conditioned on stability and conductivity properties extracted from quantum simulations.
None of this displaces classical computational chemistry. The right framing is hybrid: density functional theory and coupled-cluster methods on classical HPC handle the bulk; the quantum device handles the strongly-correlated electronic structure that classical methods either get wrong or scale exponentially badly on. QML enters as the layer that learns to interpolate between expensive quantum evaluations — a surrogate model trained on quantum-generated data, which is one of the cleaner uses of small quantum neural networks.
If you want the architectural picture of how this fits together — the data flow from chemistry workload through hybrid solver to materials candidate — the Ireland Quantum 100 programme overview covers it, and there's a deeper write-up specifically on the climate workload prioritisation.
Where to start this week
If you're a researcher or engineer trying to get useful with QML in 2026: install PennyLane, pick a problem where the data is genuinely quantum or genuinely small and structured, and write a variational circuit with a problem-inspired ansatz on a simulator first. Train it. Check the gradient norms across initialisation — if they're vanishing on 12 qubits in simulation, they will be invisible on 100 qubits with noise. Only then move to hardware, and only with error mitigation in the loop. Skip the MNIST tutorials. Skip the generic hardware-efficient ansatz. The interesting work is narrower than the field pretends, but it's real, and there's room in it.