⚛️ quantum physics

OmniQEC: discovering practical quantum error-correcting codes by an AI scientist

OmniQEC is an AI scientist framework that leverages large language models and a synergistic slow-fast search workflow to discover practical, hardware-friendly quantum error-correcting codes that outperform existing benchmarks by co-designing code structure, syndrome extraction, and decoding.

Original authors: Ge Yan, Shanchuan Li, Pengyue Ma, Qixin Zhang, Pingchuan Ma, Jianping Wang, Min-Hsiu Hsieh, Yuxuan Du

Published 2026-07-29

📖 7 min read🧠 Deep dive

CC BY 4.0

Original authors: Ge Yan, Shanchuan Li, Pengyue Ma, Qixin Zhang, Pingchuan Ma, Jianping Wang, Min-Hsiu Hsieh, Yuxuan Du

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a super-powerful computer that thinks with the weird, wobbly rules of the quantum world. The problem is, these quantum bits (qubits) are incredibly fragile; a tiny whisper of heat or a stray magnetic field can make them forget what they were doing, turning a brilliant calculation into gibberish. To fix this, scientists use a trick called Quantum Error Correction (QEC). Think of it like a team of detectives protecting a secret message. Instead of writing the message on one piece of paper that could get torn, they write it across a whole team of people. If one person gets distracted or makes a mistake, the others can figure out what the original message was supposed to be and fix it.

However, designing this "team of detectives" is a nightmare. The rules for how they stand, talk, and check each other depend on the specific hardware you are using, the tools available to listen in on their conversations, and the math used to decode the message. If you design a team that looks perfect on paper but doesn't fit the room you're putting them in, the whole system fails. For a long time, scientists have been trying to find the perfect team structure by hand, but the number of possibilities is so huge it feels like finding a specific grain of sand in a desert. This is where a new kind of helper comes in: an Artificial Intelligence that doesn't just guess, but actually learns from the messy reality of building these computers.

Meet OmniQEC: The AI Architect of Quantum Safety

Enter OmniQEC, a new "AI scientist" designed to discover the best possible quantum error-correcting codes for the real world. Instead of just looking at the math on a whiteboard, OmniQEC acts like a tireless, self-improving architect that builds, tests, and refines quantum safety teams until they are ready for the job.

The paper introduces OmniQEC as a system that treats the discovery of these codes as a game of "generate, test, and improve." At the heart of this system is a "conductor" (an advanced Large Language Model) that coordinates a two-speed workflow. Imagine a chef trying to create the perfect soup.

The Fast Loop: The Taste-Test Kitchen
First, the AI runs a "fast loop." This is like a quick taste test. The AI generates thousands of potential recipes (code structures) and checks them using simple, cheap shortcuts. It asks questions like, "Does this recipe have the right number of ingredients?" or "Is the math balanced?" These checks take only seconds. If a recipe looks promising based on these quick checks, it gets a ticket to the next round. This allows the AI to scan a massive library of possibilities without getting bogged down.

The Slow Loop: The Full Simulation
Then comes the "slow loop," which is the real deal. Here, the AI takes the best candidates from the fast loop and builds them out in a detailed simulation. It constructs the actual "syndrome extraction circuits"—the complex machinery used to detect errors—and runs them through a noisy, imperfect environment to see how often they actually fail. This is like cooking the soup, serving it to a panel of critics, and seeing if it actually tastes good in a real dining room. This step takes minutes or even hours per candidate, so the AI is very selective about who gets to this stage.

The Magic of Feedback
The real genius of OmniQEC is how it learns. The results from the "slow loop" (the real-world simulation) are fed back to the AI conductor. If a recipe looked great in the quick taste test but failed in the real kitchen, the AI learns why and adjusts its future guesses. It evolves its own reasoning, getting smarter with every cycle. This creates a "slow-fast synergistic workflow" where the AI uses cheap shortcuts to explore widely, but uses expensive, accurate testing to steer the search toward the truly best solutions.

What They Found: Beating the Old Champions

The researchers put OmniQEC to the test against four different families of quantum codes and three different AI "brains" (Claude, GPT, and DeepSeek). They set strict budgets for how many physical qubits (the hardware pieces) could be used, ranging from small setups to larger ones with up to 288 qubits.

The results were impressive. OmniQEC discovered codes that consistently got better at suppressing errors as more resources were added. But the most exciting finding was how these new codes compared to the current "gold standard" known as the BB codes (bivariate bicycle codes).

When the team gave OmniQEC a budget of 98 physical qubits, the AI discovered a code that outperformed the standard BB code which required 72 physical qubits (specifically the [[72, 12, 6]] code).
Even more striking, when the budget was increased to 240 physical qubits, the strongest code found by the Claude AI beat the massive BB benchmark code that uses 144 physical qubits (the [[144, 12, 12]] code).

This suggests that by optimizing for how the code actually performs in a noisy circuit (rather than just looking at abstract math scores), OmniQEC can find more efficient ways to protect quantum information.

The Trap of "Good Enough" Math

One of the paper's most important lessons is a warning against relying on old-school shortcuts. Scientists often use a simple math score called $\Phi_{code} = kd^2/n$ to rank codes quickly. The paper shows that this score can be misleading.

In their experiments, OmniQEC found codes that had lower math scores than the famous BB codes but actually performed better in the real-world simulations. It's like a student who gets a lower grade on a multiple-choice practice test but ends up acing the final exam because they understood the concepts better. The paper argues that if you only optimize for the quick math score, you might miss out on the truly best solutions. You have to look at the full picture, including how the code handles noise and decoding.

The Cost of Discovery

The researchers also checked the "price tag" of running this AI. They found that the cost of using the AI (measured in "tokens," which are like words processed by the AI) didn't skyrocket just because the codes got bigger. The cost was mostly determined by which AI brain they used. For example, the Claude backend offered the best balance between performance and cost, while DeepSeek was the cheapest but found slightly weaker codes. This suggests that the AI's ability to reason and learn from its mistakes is more important than the sheer size of the code it is designing.

Why This Matters

The paper concludes that OmniQEC is a powerful new tool for "co-designing" quantum computers. Instead of designing a code, then building a machine, then realizing they don't fit, OmniQEC designs the code with the machine in mind. It bridges the gap between abstract math and the messy reality of hardware.

While the results are based on simulations and not yet built on a physical quantum computer, the findings suggest a clear path forward. By using AI to navigate the complex trade-offs between code structure, hardware limits, and error decoding, we can find practical, high-performing codes that bring us closer to building a fault-tolerant quantum computer that actually works. The paper suggests that this approach could be expanded to include even more types of hardware and code families, potentially unlocking the full potential of quantum computing for everyone.

Technical Summary: OmniQEC

Problem Statement
Quantum error correction (QEC) is fundamental to scalable fault-tolerant quantum computing, yet discovering codes that remain effective on modern hardware is challenging. Traditional discovery paradigms are "code-centric," relying on algebraic properties (e.g., $[[n, k, d]]$ parameters) or inexpensive proxies like the figure of merit $\Phi_{code} = kd^2/n$ . These approaches often fail to capture practical determinants of performance, such as hardware connectivity constraints, syndrome extraction overhead, and decoder efficiency. Consequently, codes that appear optimal at the algebraic level frequently deliver poor logical error rates (LER) when implemented as physical circuits. The central challenge is to bridge the gap between code generation and circuit-level performance evaluation without incurring prohibitive computational costs.

Methodology: OmniQEC Framework
The authors introduce OmniQEC, an AI scientist designed to discover practical QEC codes by directly optimizing the circuit-level logical error rate. The system employs a self-evolving, dual-loop workflow orchestrated by Large Language Models (LLMs):

Orchestrator: An LLM-based agent interprets user-defined objectives (e.g., target code family, qubit budget, connectivity) and manages the discovery memory. It coordinates the generation of code-construction programs and routes information between loops.
Fast Loop (Code-Level Screening): A generative search agent proposes executable construction programs for various qLDPC families (Bivariate-Bicycle, Trivariate-Bicycle, Lifted-Product, Generalized Lifted-Product). These candidates are rapidly screened using code-level properties (validity, logical qubits $k$ , distance $d$ , and $\Phi_{code}$ ). This loop allows for the exploration of a large population of candidates using inexpensive proxies.
Slow Loop (Circuit-Level Evaluation): Promising candidates from the fast loop are passed to a circuit-synthesis module, which compiles them into syndrome-extraction circuits based on specific hardware constraints (native gates, connectivity). A circuit-evaluation module then estimates the logical error rate using noisy sampling and configurable decoders (e.g., BP+OSD, BP+LSD, Relay-BP).
Feedback Mechanism: The circuit-level evidence (LER) and associated reasoning trajectories are fed back to the orchestrator. This allows the system to refine its search strategy, evolving the generation of candidates in subsequent iterations to prioritize regions of the design space that yield superior physical performance.

Key Contributions

Paradigm Shift: OmniQEC moves QEC discovery from optimizing algebraic proxies to directly optimizing the implementation-level logical error rate.
Dual-Loop Architecture: The system reconciles the vast search space with the high cost of physical evaluation by combining a fast, proxy-based exploration with a slow, physics-grounded validation loop.
Self-Evolving Reasoning: The LLM orchestrator utilizes a memory of past iterations to iteratively improve construction proposals, effectively learning from circuit-level failures and successes.
Hardware-Aware Co-Design: The framework integrates code generation, syndrome-extraction synthesis, and decoder selection into a unified process, ensuring discovered codes are compatible with specific hardware constraints.

Experimental Results
The authors evaluated OmniQEC across four qLDPC construction families, three LLM backends (Claude, GPT, DeepSeek), and 14 physical-qubit budgets ( $N$ ).

Performance Scaling: The discovered codes exhibit a clear resource–performance frontier, with logical error suppression improving as the physical-qubit budget increases.
Benchmarking: The system discovered codes that outperform standard Bivariate-Bicycle (BB) benchmarks. Specifically, codes discovered with $N=98$ physical qubits surpassed the BB $[[72, 12, 6]]$ code, and the strongest results from the Claude backend at $N=240$ surpassed the BB $[[144, 12, 12]]$ code.
Proxy Mismatch: The study revealed a significant discrepancy between code-level proxies and circuit-level performance. Many discovered codes with lower $\Phi_{code}$ scores achieved superior LER compared to high-scoring reference codes, validating the necessity of circuit-level optimization.
Robustness: The performance advantage of the discovered codes persisted across a range of physical error rates ( $p \in [0.002, 0.01]$ ), not just the specific rate used during the search.
Ablation Studies: Removing the slow-loop feedback (relying only on code-level ranking) or removing all feedback significantly degraded performance and increased variance, confirming the critical role of the dual-loop synergy.

Significance and Claims
The paper claims that OmniQEC establishes a physically grounded framework for discovering qLDPC codes that admit resource-efficient processor-level implementations. By demonstrating that AI-driven, circuit-level co-design can outperform traditional expert-driven, algebraic optimization, the work paves the way for more practical fault-tolerant quantum computing architectures. The authors position OmniQEC not as a final solution, but as a scalable route toward autonomous QEC discovery, highlighting future directions such as integrating more efficient scientific tools, extending to multi-agent systems for end-to-end co-design, and adapting to specific hardware calibration data. The findings suggest that the "code-centric" paradigm is insufficient for the era of early fault-tolerant processors and that direct optimization of physical performance is essential.