Active Inference & Spatial AI
The Next Wave of AI and Computing
FTQC Arrived Early: How AIX Quietly Accelerated the Quantum Timeline in April 2026
- June 15, 2026
Seed IQ governed today’s noisy IBM quantum processors into fault tolerance, then composed the full FTQC primitive pipeline and computed real molecules to chemical accuracy — on hardware anyone can rent.
For most of the past decade, the quantum computing industry has agreed on one thing: fault-tolerant quantum computing is the threshold a machine must cross before it becomes truly useful, and that threshold is years away. The prevailing roadmap calls for far larger machines, deeper error correction, and on the order of a thousand or more physical qubits to protect a single logical one. Almost everyone in the field is building toward that future.
Between April 9th and April 25th, 2026, AIX achieved this breakthrough — verified FTQC.
On June 7, 2026, AIX Global Innovations published a technical report documenting something different. Our paper, Governed Fault-Tolerant Quantum Computing on Commodity NISQ Hardware, records what we believe is the first end-to-end fault-tolerant quantum computing (FTQC) stack to clear all four strict FTQC requirements at the same time on commodity superconducting hardware — the kind of noisy processor any researcher can rent. Not a private research machine. Not custom silicon. Not a simulation. We ran it on rented live, noisy, IBM Quantum Heron r2 and r3 processors accessed through a standard IBM Quantum public cloud subscription.
Seed IQ held all 150 qubits of the register — essentially the entire processor IBM made available — as a single entangled logical system at near-perfect fidelity, with zero recorded logical errors.
Crossing the FTQC line was the threshold, not the finish-line, and it placed us in territory the field has no map for. Being first to cross it on commodity hardware meant there was no established way to compute on a fault-tolerant stack, because the field has never had one there to compute on. That is where the pioneering began. We built the primitive compute pipeline, the means of composing fault-tolerant primitives into working computation, then proved it the hardest way available: computing the ground-state energies of real molecules to a level of accuracy not previously demonstrated on quantum hardware. The field has been waiting to cross the FTQC line. We crossed it, then solved the problem no one else had reached: how to compute with it.
What This Means, in Simple Terms
Quantum computers are powerful in principle but fragile in practice. Their basic unit, the qubit, is so sensitive to noise, heat, and interference that errors accumulate almost immediately. Fault tolerance is the property that lets a machine keep computing reliably despite that noise. It is widely seen as the gate to every high-value quantum application, because the problems worth solving — new catalysts, drug binding, advanced materials, energy systems — all live on the far side of it.
Today’s commercially available machines are called NISQ hardware: Noisy, Intermediate-Scale Quantum processors. The conventional way to make them fault-tolerant is to add massive physical redundancy, spending hundreds or thousands of physical qubits to create one more reliable logical qubit. That is why useful FTQC is usually placed in the 2030s.
Seed IQ takes a different route. Rather than waiting for the hardware to become large enough to brute-force the noise away, it governs the computation as it runs — steering the noisy system into a coherent, fault-tolerant operating envelope on the hardware that exists right now. The result is not a perfect machine. It is a governable one.
Why We Applied Seed IQ to Quantum Hardware
Seed IQ is an execution governance engine for complex systems. It was not originally built for quantum computing. It was designed to govern unstable, high-dimensional environments where local instability cascades into system-level failure — autonomous logistics, data centers, financial models, infrastructure. Quantum hardware is simply the most unforgiving complex system of all. Noise, decoherence, crosstalk, calibration drift, and gate error are not rare faults; they are the operating condition, and they unfold in nanoseconds.
That reframing was the entire premise. If Seed IQ can govern complex systems, then a quantum processor should be treated as a governable system rather than a fragile one waiting to be perfected. The dominant approach asks how much hardware it takes to overwhelm the noise. We asked instead whether the execution itself could be governed: whether a noisy quantum system could be held inside an admissible operating envelope and made coherent enough to compute. On live IBM hardware, the answer was yes.
The d=1 Inversion
The architectural shift in the report is what we call the d=1 inversion.
The conventional path scales toward larger surface-code distances. More distance means more physical qubits per logical qubit and a lower logical error rate, but it carries a steep cost on real hardware: more stabilizer extraction, more syndrome decoding, more operations, more depth, and more chances for noise to accumulate. A distance-25 code — the kind of target on IBM’s 2029 roadmap — assumes on the order of a thousand or more physical qubits for every logical qubit.
This is the currently accepted narrative in the quantum field, and it does indeed have a positive effect in error correction – the logical error rate falls with code distance. The other side of that narrative, though, is that it also has a negative effect on fidelity, increasing decoherence with increased code distance. A problem the quantum industry does not currently have a solution for.
What our report demonstrates is that execution governance can serve as an operational substitute for code distance. Seed IQ held a 150-qubit persistent encoded register at substrate distance d=1 — roughly one physical qubit per logical qubit, plus a handful of ancillas, for 156 physical qubits in total — and preserved logical fidelity through governance of the encoded layer rather than through deeper physical redundancy.
In plain terms: a quantum computer only does useful work when its qubits act together as one entangled, coherent system, and that coherence is precisely what hardware noise tears apart. Seed IQ held all 150 qubits of the register — essentially the entire processor IBM made available — as a single entangled logical system at near-perfect fidelity, with zero recorded logical errors. The ceiling of 150 was the chip’s, not the method’s; it was every qubit the hardware offered. On larger machines, the same Seed IQ governance is built to hold more.
That is the inversion. The field assumed useful FTQC required going deeper into physical-to-logical overhead. We showed that governed execution can hold the computation at d=1 and still clear the FTQC requirements. If governance can stand in for a large fraction of that overhead, useful quantum compute does not have to wait for a future hardware roadmap. It can begin on the hardware that exists now.
What We Achieved in Eight Weeks
Our first hardware run was April 9, 2026. By late April we had cleared verified FTQC, and from there the work moved quickly into frontier territory.
Originally, we validated surface-code error correction at distance 3 and distance 5, cutting the logical error rate by 88.5% at d=3 and by 93.1% at d=5, where the conventional decoder baseline collapsed. (We wrote an article denoting this achievement as our first hardware run.)
What we noticed with that first attempt, following the current quantum distance code narrative (physical qubits per logical qubit), was that the error rate did, in fact, reduce with increased code distance, but the fidelity rate suffered because things like cross-talk are introduced and increase with more depth.
It occurred to us that increasing code distance may not be necessary. So we tried distance-1: one physical per one logical qubit. And sure enough, we maintained entanglement with near-perfect fidelity and zero detected errors. We attempted 50 qubits, then 100, then all 150 available qubits available within the IBM Heron QPU processors.
Next, we cleared the universal FTQC primitives (elements that sound like straight science fiction) — teleportation, lattice-surgery CNOT, a T-gate via magic-state injection, and logical memory. These are the elements necessary to enable and maintain an open quantum computing channel. Once we confirmed then individually, we composed them on a single persistent encoded register. The composed primitive chain ran across 22,500 circuits per run at a perfect runtime admissibility pass rate, with zero detected logical errors, replicated across two independent calibration windows.
FTQC was now verified and repeated multiple times across multiple IBM quantum processors.
With FTQC verified and its primitives composed, we faced the question no one had reached yet: how do you actually compute with this? There was no method to look up or inherit, because there had never been a fault-tolerant stack on this kind of hardware to compute on. So we built the primitive compute pipeline from scratch — the orchestration that turns teleportation, lattice-surgery CNOT, magic-state-injected T-gates, and logical memory into a working computation. It prepares a problem, executes it under live governance, verifies every step against admissibility, and returns a result you can trust. This is the layer that turns a fault-tolerant machine from something that exists into something that computes, and it is where the bulk of the pioneering work was spent.
Then we put this novel quantum computing stack to work on chemistry, and the progression is the point. Across twenty-two governed runs spanning H2, LiH, H2O, the BeH2 equilibrium, and the strongly multireference BeH2 transition state, all twenty-two committed runs landed well within chemical accuracy. H2 set the baseline, and the baseline is where the gap is easiest to see.
H2 is the molecule every quantum chemistry effort starts with, so it makes the cleanest head-to-head. In May 2025, Quantinuum, a trapped-ion leader running on custom-built hardware, published the first error-corrected computation of H2’s ground-state energy. By their own description the work was only partially fault-tolerant. Their own roadmap puts full fault tolerance around 2030.
The Quantinuum result landed outside of chemical accuracy, missing it by more than ten times. It took hours to run and cost tens to hundreds of thousands of dollars per QPU run.
Our run cleared full fault tolerance and landed inside chemical accuracy, more than a hundred times closer to the exact answer at 0.016 milli-Hartree. It finished in about 3.5 minutes, used under 80 seconds of quantum-processor time, and cost less than one hundred dollars.
Same molecule, same benchmark. Theirs took hours and tens to hundreds of thousands of dollars per QPU run and still missed chemical accuracy. Ours took minutes and under one hundred dollars, achieving chemical precision. The difference is partial fault tolerance versus full FTQC.
The molecules we tested were not chosen at random. Each was picked to be harder than the one before, and each run pushed our compute pipeline further. H2 is the simplest. LiH and H2O are larger and more tightly correlated. BeH2 at its equilibrium structure is harder still, and the BeH2 transition state sits in territory where the standard classical shortcut chemists rely on stops working altogether. It was a deliberate climb in difficulty, and the way we built the pipeline out as we went.
Every result cleared a bar far tougher than the one the field aims for. Chemical accuracy is the threshold a result has to reach to be scientifically useful. Spectroscopic accuracy is far finer, and wavenumber accuracy finer still — the level used in high-resolution molecular spectroscopy. Every molecule landed inside spectroscopic accuracy, and BeH2 at equilibrium, one of the hardest cases, reached wavenumber accuracy, the tightest tier of all.
BeH2 at equilibrium reached wavenumber accuracy, the only sub-wavenumber chemistry result ever committed on a quantum computer, and it reproduced to twelve decimal places across different chips on different days, a level of reproducibility that is unprecedented for quantum chemistry on hardware.” — Denis Ovseyenko, Chief Innovation Officer, AIX Global Innovations
The direction is the point. As the molecules grew more complex, the precision held, and at the demanding BeH2 equilibrium it reached the finest tier we recorded. Even the single hardest case, the transition state where the classical shortcuts fail, stayed within spectroscopic accuracy. That is what we have said about Seed IQ from the start: it governs by resonance, and resonance strengthens, rather than breaks down, as a system grows more complex. This was not one lucky result. It was a deliberately escalating pipeline, and it ran on rented hardware.
Why the Chemistry Results Matter
Molecules are quantum systems, which is why quantum chemistry is one of the most commercially important promises of the technology. Understanding how electrons behave, how bonds form and break, and how molecular structures settle into their lowest-energy states connects directly to drug discovery, materials, catalysts, batteries, energy systems, and advanced manufacturing.
Ordinary computers can model simple molecules well. But as molecules get larger and their electrons interact in more tangled ways, the math explodes, and classical computers are forced to cut corners. The hardest molecules are exactly the ones where those shortcuts break down, and those are often the ones that matter most. This is the gap quantum computers are supposed to eventually close.
Until now, chemistry on real quantum hardware has been stuck in a holding pattern: small molecules, short calculations, and heavy error-patching, producing results that show promise but can’t yet be trusted as a dependable way to compute. We didn’t work that way. We ran our chemistry through our governed fault-tolerant pipeline, which is a fundamentally different thing, and the difference shows up in the accuracy.
Take BeH2, the hardest molecule we ran. At its stable structure, our result came within 0.000595 milli-Hartree of the exact answer. That is roughly 2,700 times finer than the accuracy chemists consider good enough, and the most precise chemistry result ever recorded on a quantum computer. We then ran BeH2 in a far more difficult configuration, the kind where the usual classical methods stop working, and it still beat the gold standard those methods are measured against.
For business readers, the implication is direct: this is no longer only about proving quantum hardware can eventually compute. It is about generating quantum-computed results, with real scientific value, now.
The Proof, and Why it Holds Up
Extraordinary claims require extraordinary evidence, and a breakthrough this significant has to be verifiable, so we preserved the workload records, circuit data, and execution evidence needed for qualified reviewers to examine the results. The beauty in achieving this on 3rd party rented hardware is we have not operated under any special lab conditions or controlled circumstances, and we can demonstrate successful results with new live runs at any time.
Our technical report is a public preprint (DOI 10.5281/zenodo.20585365). It documents our full progression from April 9th — June 2026 across five IBM Heron processors spanning two generations — IBM Fez, IBM Kingston, IBM Marrakesh, and IBM Pittsburgh on the r2 family, and IBM Boston on r3 — recorded workload by workload through every phase: surface-code error correction, the universal FTQC primitives, the composed primitive pipeline, and the chemistry commits at the tail. On IBM Quantum, every circuit is logged as its own workload with its own Workload ID and full execution record, each auditable against IBM’s own records — tens of thousands of them across the campaign, with the composed pipeline alone accounting for 45,000 across two calibration windows and the twenty-two chemistry runs that close the campaign accounting for 198. We are inviting that scrutiny, not avoiding it.
The strongest single piece of evidence is also the most counterintuitive, so it is worth stating carefully. Across the chemistry campaign, materially different IBM chips — with different calibration windows, crosstalk, and noise profiles — repeatedly converged to the same committed molecular energies, agreeing to twelve decimal places — signifying an extraordinary level of precision and accuracy. H2 produced twelve-decimal identity between IBM Kingston and IBM Marrakesh. H2O produced it across IBM Fez, Marrakesh, and Kingston. BeH2 equilibrium produced it across runs on two different chips. The BeH2 transition state produced it across two processor generations.
A skeptic’s first instinct is that identical numbers across different noise must mean the result is fixed by the classical post-processing rather than the quantum hardware. That is exactly the question the report addresses head-on. The twelve-decimal identity is the engineered signature of Seed IQ’s admissibility-and-projection contract: the governed envelope is designed so that noisy measurement vectors from different chips identify the same physically admissible fixed point on the trial-state subspace. The committed energy is then computed from each chip’s own measurement record by direct counting at that point — with no binning, no precomputed energy curve, and no offline lookup. What makes the agreement meaningful is not the number format. It is that chips with materially different noise agree to this degree of exactness, which is the operational signature of governance doing what it was built to do.
A single strong result on one chip could be dismissed as an anomaly. Convergence across chips, generations, and calibration windows cannot.
Where This Sits Relative to the Field
Two days after we quuietly published our breakthrough report, Google Quantum AI gave a public update reflecting their quantum progress, as well as a mainstream roadmap.
The field of quantum computing is still moving toward long-lived logical qubits, larger systems, and lower error rates, and has not yet shown the upper quadrant Google calls “quantum benefit,” where an application is both commercially relevant and effectively impossible to replicate classically. That is a fair description of the consensus path, and Google’s own error-correction work is real and important.
Our results reframe the shared assumption underneath that path. Better hardware will always matter expanding what becomes possible. But our work suggests the missing layer is not only hardware. It is governance.
The industry has been trying to scale the hardware so that it is good enough to compute.
We showed that with Seed IQ’s execution governance, current hardware already is.
From Quantum Hardware to a Quantum Operating System
Classical computing did not become broadly useful because hardware alone improved. It became useful when operating systems made hardware manageable — abstracting complexity, governing resources, coordinating execution, and creating the layer through which applications could run reliably. Quantum computing needs the same transition, adapted to quantum reality.
A quantum operating system cannot simply schedule jobs or compile circuits. It has to govern execution under live noise, preserve coherence, manage admissibility, coordinate primitive composition, handle magic-state injection, and enforce valid transitions across the computation — knowing when to act and when not to. That is what Seed IQ is beginning to do. It is not a compiler, an optimizer, or error mitigation. It is an execution governance layer for quantum computation.
- The first phase proved FTQC.
- The second composed the primitive pipeline.
- The third began chemistry.
The next is to operationalize this into a broader quantum compute layer that makes quantum hardware useful across application domains.
The Commercial Picture
Universal quantum computation needs more than Clifford operations; it needs non-Clifford capability, delivered through T-gates and magic-state injection. The industry has generally assumed reliable magic-state production requires large-scale FTQC hardware and heavy distillation overhead. Our work points elsewhere. We achieved this without an offline distillation factory — magic states were injected inline on commodity hardware under governance. That turns magic-state capability into a service layer rather than a hardware mega-project.
This creates a category that did not previously exist in quantum computing: governed quantum execution, where the system is not merely correcting errors, but actively controlling, verifying, and admitting each operational result against execution-level constraints.
The near-term value is no longer only in building future hardware; it is in governing existing hardware so it produces useful compute today.
- For hardware makers, their systems can become commercially relevant sooner.
- For cloud quantum platforms, higher-value workloads become supportable sooner.
- For enterprises in pharma, materials, energy, logistics, finance, defense, and data centers, the useful quantum timeline is no longer gated entirely by future hardware scale.
AIX’s position follows from this directly. We are not competing as another hardware company, and we are not waiting on someone else’s roadmap. We built the governance layer that makes quantum hardware usable, delivered through controlled access with the proprietary execution methods held as protected IP.
What This Means for Investors and Industry Leaders
Quantum computing has been valued on future potential — real, but distant, with the largest returns assumed to arrive only when fault-tolerant machines finally exist. AIX changes that timeline.
We are not asking the market to believe we may someday reach FTQC, compose its primitives, or compute useful chemistry.
Our report documents that we have already done all three, on hardware available today, with a public and independently auditable proof trail.
That reframes the opportunity. The defensible near-term value sits in the execution layer, not in a new generation of physical qubits — and the layer is hardware-agnostic by design, applicable across superconducting processors and other quantum modalities. The position is a category, an evidence base, and a body of protected IP, rather than a bet on a single machine.
The Field Has Been Waiting for the Future Machine. We Governed the Current Machine.
The central assumption in quantum computing may be that the machine must become perfect before it can be useful.
Our work suggests another possibility: the machine must become governable.
Hardware will keep improving, but the moment a noisy quantum system can be governed into fault-tolerant computation, the quantum timeline changes. The field no longer has to wait for perfect hardware to begin building the compute layer.
- In eight weeks we moved from a first hardware run to FTQC, from FTQC to primitive composition, from composition to chemistry, and from chemistry toward the early structure of a quantum operating system.
- We cleared the four strict FTQC requirements, composed the primitive stack
- and held chemical accuracy across all twenty-two committed chemistry runs, reaching sub-wavenumber precision on BeH2 equilibrium.
We did it on rented IBM NISQ hardware — no special machine, no controlled environment, no waiting on a future roadmap.
The quantum industry has been asking when useful fault-tolerant quantum computing will arrive. Our answer is simple. It just did.
Read the full technical report – Governed Fault-Tolerant Quantum Computing on Commodity NISQ Hardware: https://zenodo.org/records/20585365
AIX independently developed and executed the Seed IQ governance layer used in the achievement. IBM Heron QPUs provided the hardware substrate, and the validation trail is grounded in IBM hardware readouts, workload identifiers, circuit data, calibration-window records, and per-run execution evidence. The results strongly demonstrate the capability of IBM Heron hardware when governed by Seed IQ, while also underscoring that Seed IQ is not tied to a single hardware provider. Seed IQ is hardware agnostic by design and can be applied across any other superconducting QPU systems, as well as other quantum hardware modalities.
The technical report documents an eight-week hardware campaign across five IBM Heron processors: IBM Fez, IBM Kingston, IBM Marrakesh, IBM Pittsburgh, and IBM Boston.
Among the reported milestones:
· AIX cleared the four strict FTQC requirements: surface-code quantum error correction below the unencoded baseline, universal Clifford+T execution through magic-state injection, heterogeneous primitive composition on a persistent encoded register, and runtime admissibility verification on every committed result.
· AIX demonstrated what the report calls the d=1 inversion: approximately one physical qubit per logical qubit on a 150-qubit governed encoded register, with logical fidelity preserved by Seed IQ governance rather than larger physical code distance.
· AIX composed the FTQC primitive pipeline, including teleportation, lattice-surgery CNOT, magic-state-injected T-gates, logical memory, Clifford and non-Clifford execution, and chemistry computation.
· AIX executed a TELE → CNOT → T → CNOT → TELE×2 primitive composition chain across 22,500 circuits at Fgoverned=1.0000 with zero detected logical errors.
· AIX completed twenty-two governed chemistry runs across H2, LiH, H2O, BeH2 equilibrium, and the BeH2 strongly multireference transition state, with all twenty-two committed chemistry runs inside chemical accuracy.
· AIX advanced beyond chemical accuracy into spectroscopic-scale precision across multiple molecular workloads, with the BeH2 equilibrium result reaching wavenumber-level precision at ∆E=+0.000595 mHa from FCI.
For more information on AIX or Seed IQ, visit our website: https://aix.us.com/
