Latest / Quickly Quantum / Ep 4: Google's Self-Calibrating Willow Chip Hits a New Error Record
Transcript
- Seven hundred seventy-two errors per million operations. That's the new logical error rate on Google's Willow chip — and the reason it dropped is the real story: a reinforcement learning agent that taught itself to keep the chip calibrated while it was still running the computation, no humans, no downtime, no pause button. Google says it's the first time calibration and computation have been unified like this, and it builds directly on the below-threshold surface code work that made headlines last year. This is the unglamorous engineering that has to work before anyone builds a fault-tolerant machine — a quantum computer whose logical qubits, the error-corrected units built from many physical qubits, are reliable enough to trust. Stick around, we're spending real time on this one today. Welcome back to Quickly Quantum, your daily brief on the quantum frontier. It's Thursday, July 9, 2026. Let's get into it. Let's start with hardware that doesn't get enough attention: silicon spin qubits. Diraq and the Belgian chip fab imec just published a paper called 'Eight-Qubit Operation of a 300 Millimeter SiMOS Foundry-Fabricated Device' — and yes, that title is basically the whole story. Diraq's bet is that you don't need exotic new fabrication plants to build a quantum computer; you need the same 300-millimeter silicon wafers that make your laptop's processor, run through a standard chip foundry. Previously they showed two-qubit devices on that same production line hitting fidelities above ninety-nine percent. Now they've scaled that up to an eight-qubit array, still built at imec's foundry, not some bespoke quantum-only cleanroom. Why does that matter if you're not an engineer? Because the entire quantum industry has one brutal math problem: getting from dozens of qubits to the millions some architectures need to do anything useful. If you can lean on decades of silicon manufacturing know-how — the same infrastructure that makes billions of transistors a day — that scaling curve looks a lot less scary than growing everything from scratch. Eight qubits isn't a huge number on its own, especially next to superconducting chips already in the hundreds. But the significance here is the fabrication line, not the qubit count. This is Diraq proving the manufacturing pipeline holds as you add qubits, which is the actual bottleneck for silicon spin qubits going forward. It's a quieter story than a flashy new processor announcement, but for anyone tracking who can actually manufacture quantum hardware at scale, this is exactly the kind of incremental, boring-sounding progress that ends up mattering most in five years. Meanwhile, in architecture experiments — physicists at ETH Zurich just demonstrated something genuinely different: using mechanical vibrations, tiny physical resonators that oscillate like microscopic tuning forks, as a form of quantum working memory. Most quantum computers store and shuttle information using microwave photons or the internal states of qubits themselves. This team is asking whether you can park quantum information in mechanical motion instead — essentially treating a vibrating structure as a memory bank the processor can write to and read from. Why bother? Because memory is one of the quieter bottlenecks in quantum computing. Qubits are expensive, fragile, and hard to keep coherent — meaning they hold their quantum state — for long. If you can offload information into a mechanical resonator that's more stable or easier to scale, you free up your precious qubits to do actual computing instead of babysitting data. It's the quantum equivalent of adding a hard drive instead of cramming everything into RAM. And honestly, nobody's claiming this beats existing memory approaches yet — the material we have here is short on hard numbers, no error rate, no coherence time you can stack up against Google's or IBM's superconducting memories. That's worth flagging, because architecture demos like this often look impressive in a press release and take years to prove out in a real machine. Still, this is the kind of exploratory materials-and-mechanics thinking that occasionally reshapes an entire hardware roadmap, and it's worth having on your radar even in its early, unproven form. Now a smaller item, but one worth putting in context. D-Wave's CEO, Alan Baratz, posted on X this week highlighting that D-Wave has landed a National Science Foundation grant — one point five seven million dollars — through the National Quantum Virtual Laboratory program, backing something called the ERASE project, a Yale-led effort on dual-rail gate-model fault tolerance. Let's be clear about the numbers: one point five seven million dollars is not a huge check by quantum-industry standards, and this grant was actually announced last week — Baratz was recirculating it, not breaking new news. So why mention it at all? Because of what it signals, not what it pays for. D-Wave built its entire business on quantum annealing, a fundamentally different, more specialized approach to optimization problems than the gate-model quantum computers everyone else is racing to build — the Willows, the IonQs, the IBMs of the world. Annealing has never been a clean fit for general-purpose fault-tolerant computing. This grant puts D-Wave's name, even in a supporting role, on a gate-model fault-tolerance project using dual-rail qubits, a design that encodes information to make certain errors easier to detect. That's D-Wave quietly hedging on the chance that its annealing-only strategy doesn't carry the company through the next decade. It's a small grant attached to a much bigger strategic question about whether D-Wave stays a specialist or tries to become a generalist. Sticking with theory for a second, because a paper in PRX Quantum this week is the kind of result that doesn't make headlines but changes what's possible on paper. Researchers describe a new fault-tolerance scheme built on qLDPC codes — quantum low-density parity check codes, a family of error-correcting codes that promise to protect qubits using far fewer extra qubits than the surface code Google uses. As the journal's own account, @PRX_Quantum, put it on X, the scheme delivers 'fault-tolerant quantum computation with constant qubit overhead and low time overhead... enabled by parallelized code surgery and locally testable state preparation.' In plain terms: constant qubit overhead means the number of extra 'helper' qubits you need doesn't grow as your computation gets bigger, and parallelized code surgery is a technique for stitching together error-corrected operations side by side instead of one at a time. Why should you care about qubit overhead? Because it's the number nobody outside quantum theory pays attention to, and it's the number that decides whether fault-tolerant quantum computing needs a million qubits or ten million. This is theoretical work, run on paper and in simulation, not on a chip — don't expect this scheme in a lab next month. But it's part of a genuinely fast-moving theoretical race right now, with multiple groups racing to shrink the resource cost of fault tolerance, and today's result is a serious entrant, from a peer-reviewed physics journal, not a press release. Now a commercial deal that's part of a bigger trend. German ion-trap maker QUDORA is partnering with QAI Ventures to deploy a QUDORA ion-trap quantum computer in South Korea, integrated directly into an AI data center. Ion-trap machines use individually trapped atoms as qubits, controlled with lasers — a different physical approach than the superconducting circuits Google and IBM favor, generally prized for high qubit fidelity even if it's historically been harder to scale to huge qubit counts. The interesting part isn't really the hardware, though — it's the pairing with an AI data center. We're seeing a wave of these hybrid deployments where quantum hardware gets bolted onto existing AI infrastructure, betting that quantum processors will eventually plug into classical AI workloads as accelerators, the way GPUs did. Whether that bet pays off depends entirely on quantum computers actually being useful for something a data center customer wants to buy today, and right now that's still mostly a research question, not a product one. Geographically, this is also notable as another Europe-Asia commercial tie-up in quantum, alongside a string of similar partnerships this year connecting hardware makers with money and infrastructure across Asia. Nobody's claiming this Korea deployment does anything a superconducting or trapped-ion system elsewhere hasn't already done — the news here is market expansion and partnership structure, not a technical breakthrough. Worth watching for whether these AI-data-center-plus-quantum pairings become the standard commercial playbook or stay a one-off marketing move. Let's do a quick policy roundup, because governments on both sides of the Atlantic made moves recently. In Washington, the White House held a summit on American quantum innovation. The Office of Science and Technology Policy's account, @WHOSTP47, said on X that nearly one hundred participants from industry, academia, and government took part, framing it as the start of implementing an executive order aimed at, in their words, 'delivering a scientifically relevant quantum computer and advancing quantum sensing and networking.' That's The Quantum Insider's exclusive coverage, and we haven't independently confirmed the details beyond what's been reported, so treat that framing as the administration's own characterization of the event rather than settled fact. Meanwhile in Europe, the EuroHPC Joint Undertaking — the group that funds and coordinates high-performance computing across the European Union — is opening researcher and industry access to six quantum computers it's already funded, and co-funding two more, all aimed at integrating quantum hardware directly with Europe's existing supercomputers. That's a single-source report from Quantum Zeitgeist, so again, we're treating it as reported rather than fully verified on our end. Put both stories together and you get the same underlying story on two continents: governments are done treating quantum as a curiosity and are building the boring infrastructure — funding programs, physical access, executive orders — that turns lab demonstrations into an actual industrial base. None of this is a technical breakthrough. It's plumbing. But plumbing is how you win a technology race that plays out over a decade, not a headline cycle. Our main story today is the one I teased at the top: Google Quantum AI, working with Google DeepMind, published a peer-reviewed paper in Nature yesterday, July 8th, describing a reinforcement learning system that keeps a quantum chip calibrated while it's actively computing. The paper is led by Vlad Sivak and Alexis Morvan, and it runs on Google's Willow superconducting processor — the same chip that made headlines in late 2024 and through 2025 for finally getting a surface code below the 'break-even' threshold, meaning that as you add more physical qubits to the error-correcting code, the logical error rate goes down instead of up. That threshold result was the proof that quantum error correction could work in principle on Google's hardware. This new paper is about something less flashy but arguably just as important: keeping it working. Here's the problem this solves, in plain terms. A quantum processor is essentially a very delicate analog instrument. Every qubit gets tuned — control voltages, microwave pulse timing, frequencies — to sit in a very narrow operating window. Get out of that window, even slightly, and your error rate climbs. The trouble is that real hardware drifts. Temperatures shift, materials age, control electronics wander. Traditionally, engineers deal with this the way you'd deal with a car needing an alignment: you take the machine offline, run a calibration routine, tune everything back into spec, and then start computing again — hoping it doesn't drift too much before your calculation finishes. That start-stop cycle, calibrate-then-compute, has been baked into how quantum computers operate since the beginning. Google's new approach throws that cycle out. Instead of treating error-detection events — the signals the surface code produces when it catches a qubit going wrong — purely as something to correct and discard, the team repurposed those same signals as a training signal for a reinforcement learning agent, a piece of software that learns by trial and reward, the same broad family of AI behind systems like DeepMind's game-playing agents. That agent continuously adjusts more than a thousand control parameters in real time, while the chip is running an actual computation, no pause required. Google's own framing, from the announcement on X by @GoogleQuantumAI: 'We've unified calibration with computation on our Willow processor, training a reinforcement learning agent to stabilize the logical qubit and pave the way towards a quantum computer that continuously learns from its errors.' The headline number is a logical error rate of 7.72 times ten to the minus four on the surface code — the leading error-correction scheme that groups many fragile physical qubits into one much more reliable logical qubit. Google says this RL steering improved the surface code's stability three-and-a-half-fold against injected drift, meaning they deliberately introduced disturbances to test whether the agent could compensate, and it did. They also ran the same trick on a second error-correction scheme, the color code, reaching an average logical error rate of 8.19 times ten to the minus three. And in simulation, they found the RL agent's optimization speed holds steady even as the number of control parameters scales into the thousands — a hint, though not proof, that this could scale to the tens of thousands of parameters a much bigger machine would need. So here's my read on why this matters beyond the number. For years, the roadmap to fault-tolerant quantum computing — a machine whose logical qubits are reliable enough to run long, complex algorithms without falling apart — has quietly assumed that calibration is a solved, boring problem you handle before the real computing starts. Google's paper argues that assumption breaks down as you scale up. If you're running a computation for hours, on a chip with tens of thousands of control parameters, you can't just calibrate once and hope the hardware holds still. Drift catches up with you. So the system needs to tune itself continuously, without stopping the math, and that's exactly the phrase Google used: a quantum computer that, in their words, 'learns from its errors and never stops computing.' That's not a small ambition — that's a description of core infrastructure for any large fault-tolerant machine, on any hardware. And notice that last part, because Google was explicit about it in the paper: this framework is, quote, 'directly applicable to any physical qubit modality and quantum error correction architecture' — not just superconducting circuits like Willow. If that generality holds up, this isn't just a Google-Willow trick; it's a control technique that ion-trap, neutral-atom, and photonic companies could, in principle, adapt to their own hardware. Now, the skeptic in me wants to slow down for a second. This is calibration and control-loop engineering, not a new qubit count, and it is not a demonstration of a useful algorithm running end-to-end. Google itself is framing this as infrastructure, not an application milestone — they're not claiming they ran anything a customer would pay for. And 7.72 times ten to the minus four, while a genuine record for this kind of continuously-adaptive scheme, is still far above the error rates you'd need for full, large-scale fault tolerance; the gap between a record logical error rate in a controlled demo and running a commercially useful algorithm reliably remains enormous. It's also worth saying plainly: this is Google's own team, on Google's own hardware, using Google's own benchmarks. There's no independent replication here, and there rarely is for in-house superconducting results — that's just the state of the field right now, not a knock on this specific paper. But here's what would change my mind toward the more excited reading: if someone outside Google — a different lab, a different qubit modality, ideally a competitor — takes this reinforcement-learning-as-calibration idea and reproduces even a modest version of it on their own hardware. That's the test of whether 'applicable to any qubit modality' is a real claim or just a nice line in a discussion section. Time for the Hype Check. I'm putting this one at a 7. The paper is peer-reviewed, published in Nature, the number is real, and the shift from static to continuous, self-learning calibration is a genuinely useful piece of engineering that other hardware efforts will probably want to copy. But it's not an 8 or a 9, because this is infrastructure progress, not a new capability you can point to and say a quantum computer just did something useful it couldn't do before. Real chip, real measurement, real record — just don't let anyone tell you fault-tolerant quantum computing arrived this week. If you're the kind of person who wants the quantum headlines without the marketing gloss, following the show is the easiest way to make sure you don't miss a day — new episodes drop every day, and there's always something moving in this field, from Nature papers to policy summits to deals nobody else is tracking yet. And if today's episode was useful, share it with the one person in your life who keeps asking you what quantum computing even is. That's Quickly Quantum for today. New episodes every day. This is an AI-voiced podcast, created and built by a real person using today's cutting-edge technology. And remember: nothing on this show is financial advice. I'm Brian Lampert — see you tomorrow.