Quantum Bits: Beginner's Guide

This is your Quantum Bits: Beginner's Guide podcast.

Did you feel it? That subtle ripple in the digital world this week—like the tremor before an earthquake? As I sit here, watching the amber glow of indicator lights in our chilly quantum lab, I can’t help but think we just crossed a frontier. Leo here, your Learning Enhanced Operator, and today on Quantum Bits: Beginner’s Guide, I’ll walk you through a breakthrough that isn’t just academic—this is the moment quantum programming became more accessible than ever.

On July 1, researchers from USC and Johns Hopkins, led by Daniel Lidar, showed the world what we’ve been waiting for: quantum computers can now outpace classical ones exponentially, with no caveats, no assumptions—just raw performance. They achieved this titanic feat using two IBM Eagle processors remotely, a detail that still gives me chills. For years, noise—those tiny, relentless quantum errors—has held us back, making even the brightest algorithms falter. But this time, they squeezed every ounce of performance from the hardware, trimming circuits, using smarter transpilation, and—most dramatically—employing dynamical decoupling. Imagine training a symphony of qubits to ignore the chaos outside and keep playing in tune. That’s what these researchers have done, allowing quantum systems to maintain their delicate coherence just long enough to show an unconditional, exponential speedup.

But the real magic for us as programmers—and for anyone who dreams of taming quantum devices—lies in how this changes the way we interact with qubits. Just yesterday, a separate team at Xanadu demonstrated a photonic qubit that can correct its own errors at room temperature. This was done using what’s known as a Gottesman–Kitaev–Preskill (or GKP) state, created right on a silicon chip. Traditionally, error correction required bundling many qubits together, multiplying complexity and cost. With this breakthrough, each qubit becomes resilient, simplifying both the hardware and the code we write. For the first time, quantum programmers can focus more on the “what” and less on the “how”—less on safeguarding their qubits, more on unleashing their creativity.

I find myself drawing parallels with the chaos outside the lab—political storms, climate concerns, even the feverish buzz ahead of this summer’s elections. We crave certainty in a noisy world. Quantum error correction—especially with self-healing qubits—offers a glimpse of that order rising from chaos. It’s not just about faster computing; it’s about resilience. Resilient machines for a turbulent world.

So, to all the builders, coders, and dreamers tuning in: the tools are transforming beneath our fingers. If you ever wanted to program a quantum computer, there has never been a more exciting moment. Send your questions, your wildest quantum topics, to [email protected]. Don’t forget to subscribe to Quantum Bits: Beginner’s Guide, share your thoughts, and catch future episodes. This has been a Quiet

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Today, I’m not just marveling—I’m outright electrified. Because last week, Quantinuum did something the industry has been chasing for decades. They finally cracked the code for a fully fault-tolerant universal quantum computer, built on the backbone of concatenated error-correcting codes. Now, if that sounds abstract, let me pull you in: imagine a symphony where every musician is a qubit. The problem? Quantum musicians are notoriously finicky; one sour note—a whiff of environmental noise—and the whole composition unravels. Traditional error correction required so many backup musicians (ancilla qubits) that we were always building orchestras too big to fit in any hall.

Quantinuum’s new protocols break this spell. They found a way to stack error correction in layers—concatenated codes—so efficiently that in many scenarios, they require zero extra ancilla qubits at all. The result is like trimming a chorus to just a handful of virtuosos—all perfectly in tune—without sacrificing harmony. Suddenly, constructing a large, reliable quantum computer shifts from fantasy to firm engineering. This isn’t just incremental. It’s the difference between scribbling quantum equations on a chalkboard and running pharmaceutical simulations, financial optimizations, or even quantum-native artificial intelligence on a real-world quantum engine that doesn’t wobble when you look at it sideways.

Let’s get granular. In the quantum lab, a qubit is a delicate thing—sometimes an ion, sometimes a loop of superconducting current, sometimes an electron spinning in silicon. This week, scientists at the University of Sydney unveiled a chip that lets you control millions of these qubits at once, all operating at temperatures colder than outer space, without upsetting their quantum dance. The chip uses cryogenic circuits to interface directly with qubits without drowning them in thermal noise. David Reilly’s team spent a decade refining this technology, and now, the buzz is that practical, desktop quantum computers are within measurable reach.

If you wonder how this makes quantum programming easier—here’s the magic: Layers of error correction become as seamless and invisible as cloud storage is to your smartphone. With more robust, scalable architectures, programming a quantum computer might soon feel less like walking a tightrope and more like driving a car—complex under the hood, but intuitive behind the wheel.

And just this week, researchers at USC demonstrated, experimentally, that quantum computers can now beat classical ones unconditionally in targeted problems, squeezing every drop of performance out of hardware with advanced techniques like dynamical decoupling and statistical error mitigation. The separation is now clear: quantum is not just promise; it’s performance.

The world outside quantum labs is full of unpredictability—finance, climate, even your commute. But just as quantum computers weave certainty from pro

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

The hum of refrigeration units is the closest thing to weather inside a quantum lab. Chilled to temperatures near absolute zero, these machines aren’t just keeping things cold—they’re preserving the fragile quantum states that fuel the world’s most promising computers. I’m Leo, your Learning Enhanced Operator, and today on Quantum Bits: Beginner’s Guide, I’ll take you inside the pulse of the latest breakthrough that’s changing how we program quantum machines and making them more approachable than ever.

It’s been a whirlwind week for quantum computing. Just last Wednesday, Quebec-based Nord Quantique announced a quantum processor that could, for the first time, achieve fault-tolerant computing with a fraction of the qubits we thought were necessary. Imagine being able to condense the power of a sprawling server farm into a device that fits in a single rack—and needs just a sip of the energy. Their “bosonic qubit,” built on multimode encoding and protected by a Tesseract code, is a marvel. By integrating error correction directly into the qubit hardware, they’ve tackled one of the core obstacles: qubits’ extreme sensitivity to noise, heat, or even the faintest electromagnetic disturbance.

Error correction in quantum computing is like a symphony—every instrument, each qubit, must be in tune. Traditionally, this has required large clusters of physical qubits to encode a single logical qubit, just to keep the information from unraveling. With the breakthrough at Nord Quantique, the error correction is built-in, sidestepping the need for massive redundancy. The result? Quantum computers that could, in the very near future, decrypt RSA keys in an hour using a tiny fraction of the energy consumed by today’s supercomputers. That’s not incremental progress; that’s an entirely new movement.

But hardware is only half the story. On the software side, researchers at Google and Quantinuum have pushed fault-tolerant programming even further. Google’s team just demonstrated “color codes” for quantum error correction—flexible new schemes that allow logical qubits to interact with unprecedented freedom, performing complex operations in three different bases. For programmers, this opens the door to faster, more efficient logical gates, and brings us closer to universal computation—where any quantum algorithm can be run reliably and repeatably.

I see echoes of this progress in current events beyond the lab. Just as quantum engineers find harmony in chaos, space agencies this week are launching constellations of AI supercomputers into orbit, seeking new order in the cosmos. Both quantum error correction and satellite constellations are about transforming fragility into robustness, unpredictability into certainty.

So, as the arc of quantum technology bends toward practical applications, we stand at a threshold. The day when anyone can program a quantum computer as naturally as a classical one is closer than eve

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Imagine this: just last week, the startup Nord Quantique unveiled a quantum computer that could solve problems 200 times faster than today’s fastest supercomputers—but with just a fraction of the energy. For me, it was a moment of déjà vu, like watching a chess champion pull an unexpected move, yet the real breakthrough wasn’t in raw speed. It was in how they integrated quantum error correction directly into the qubit hardware, solving a dilemma that has haunted quantum programming for decades. I’m Leo—the Learning Enhanced Operator—and today on Quantum Bits: Beginner’s Guide, I’ll take you inside this quantum leap and what it means for making quantum programming accessible to all.

Let’s skip the small talk and dive straight to the heart of it: quantum programming has always demanded wrestling with errors—tiny disturbances can send qubits spiraling out of their delicate states. I still remember my first hands-on with a superconducting processor: chilled to colder than deep space, I could almost hear the electric hum of possibility, but also the ticking clock. Decoherence, phase flips, a thousand ways for a computation to collapse before your eyes. Until now, mitigating those errors meant building vast code structures—layer upon layer of physical qubits to preserve a single logical one—making programming both a technical and logistical nightmare.

Nord Quantique’s “bosonic qubit” approach rewrites the rules. By embedding error correction within the qubit itself using what they call Tesseract code—a kind of quantum immune system—the need for massive redundancy vanishes. Imagine trying to tune a grand piano during an earthquake; now imagine the piano comes with built-in stabilization, instantly correcting its own off-key notes as you play. This isn’t just poetic—it’s a programming revolution. It lets us construct more reliable quantum circuits with fewer resources, opening the door to applications that only months ago lived in the realm of science fiction.

Of course, Nord Quantique isn’t alone in pushing these boundaries. Google’s team recently demonstrated “color codes” for error correction on their superconducting qubits. Color codes let logical qubits talk to each other more flexibly, enabling faster algorithms and opening yet another path around the old roadblocks. Meanwhile, researchers at Chalmers University rolled out a tenfold more efficient amplifier, minimizing the interference that causes qubit states to collapse, and inching us closer to high-fidelity quantum computation.

These aren’t isolated wins; they’re a cascade—each breakthrough making quantum programming less like wizardry and more like engineering. The implications ripple far beyond physics. As our climate, our cities, our medicines become ever more complex, we’re entering an era where programming a quantum computer could feel as tangible as coding a classical app. And with universal fault tolerance on the near horizon—than

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

The hum of the cooling system is a constant companion here—the temperature so low you see your own breath, the air tinged with a scent that’s somehow both sterile and metallic. My name is Leo, the Learning Enhanced Operator, and today I want to take you to the very edge of possibility, where quantum programming just crossed a threshold we’ve chased for decades.

You may have seen the headlines this week—news of a breakthrough that’s as monumental for quantum programming as the moon landing was for rocketry. I’m talking about the revelation from Quantinuum, who have, at last, demonstrated true “universal, fully fault-tolerant” quantum computing. Their latest work, done in collaboration with the University of California at Davis, achieved a leap we’ve only dreamed of: a system where error correction, universality, and real-time computation finally coexist, using far fewer qubits than ever before.

Let’s make this tangible. Imagine you’re trying to tune a piano, but every time you press a key, the note changes—erratic, unpredictable. That’s the daily struggle for quantum programmers: our ‘notes,’ the qubits, jitter and slip due to noise, errors, and the cruel indifference of physics. For years, error correction meant using hundreds, even thousands, of physical qubits to stabilize a single logical qubit—inelegant, expensive, and ultimately limiting.

Quantinuum’s milestone is the equivalent of crafting a piano that self-tunes in real time, with each key collaborating with its neighbors to maintain perfect harmony. Their innovation—called “code switching”—lets the computer switch between different error correction methods on the fly, combining the strengths of each. In their experiments, they used just 28 qubits for universal operations that previously required hundreds. It’s a reduction that changes the quantum landscape entirely.

But they’re not alone. Just days ago, Google’s Quantum AI team showcased “color codes” for error correction—flexible, efficient ways to build robust logical qubits out of noisy components, opening another pathway to scaling up. Meanwhile, in Sweden, engineers at Chalmers University unveiled a qubit amplifier consuming only a tenth of the power of conventional amplifiers, reducing the heat that destroys delicate quantum information. And in Australia, researchers developed a chip that finally allows for millions of qubits and their controls on a single device, all at cryogenic temperatures.

Why does this matter to you? Because every breakthrough in error correction, efficiency, and scalability brings us closer to a world where quantum computers aren’t just theoretical playthings. They’ll diagnose diseases by simulating protein folding in seconds, design unbreakable encryption in a post-quantum future, and optimize global logistics as easily as you rearrange your morning plans.

In quantum mechanics, every possibility exists at once—until, with a measurement, a single rea

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Picture this: Last week, a quantum computer in Quebec quietly shattered perceptions of what’s possible, consuming 2,000 times less power than a top-tier supercomputer while cracking problems nearly 200 times faster. Welcome to Quantum Bits: Beginner’s Guide. I’m Leo—the Learning Enhanced Operator—and today, the quantum hush of the lab hums with the promise of a breakthrough that’s been years in the making.

Let’s dive straight in. You’ve heard how quantum computers are susceptible to the faintest whispers of noise—heat, stray photons, even a lattice vibration at near absolute zero can collapse their fragile states. That’s why we’ve needed enormous clusters of “physical qubits” just to build one robust, error-corrected “logical qubit.” But this week, Nord Quantique’s team, led by Julien Camirand Lemyre, unveiled a qubit with error correction woven into its very core. Imagine a violin that self-tunes during a performance, never straying off pitch, no matter how turbulent the concert hall becomes. Their bosonic qubit and “Tesseract code” architecture could let us scale to a thousand logical qubits by 2031—fitting a quantum powerhouse into a standard data center and slashing energy use to a whisper.

But the week’s magic doesn’t end there. In Osaka, Tomohiro Itogawa and Keisuke Fujii revealed an astonishing innovation—preparing “magic states” for quantum algorithms with a fraction of the overhead we thought necessary. Traditionally, distilling these high-fidelity states was a laborious, qubit-hungry process—a bit like extracting gold dust from tons of ore. Their new “level-zero” distillation technique streamlines this, requiring only a handful of qubits and dramatically reducing spatial and temporal costs. This leap means we’re inching towards error-tolerant quantum computation that’s both scalable and practical for real-world use—imagine encrypted banking or drug discovery powered by quantum engines immune to everyday environmental chaos.

All of this is set against the vibrant backdrop of rapid progress: Australian researchers, just days ago, crafted a cryogenic chip that allows for millions of qubits on a single wafer. At Google, Alex Bourassa’s team is pioneering “color codes” for error correction, promising faster, more flexible quantum operations on their superconducting Willow chip. Even magic state “injection”—once a major bottleneck—now looks poised for dramatic simplification, thanks to these colorful advancements.

Think of today’s news: just as the world scrambles for more sustainable supercomputing—whether for AI or climate modeling—quantum circuits are learning to thrive not in noisy chaos, but in engineered harmony. The symphony of quantum hardware and software is reaching new crescendos.

Quantum computing is no longer just a scientific marvel—it’s fast becoming an essential tool for the world’s hardest problems. Thank you for tuning in to Quantum Bits: Beginner’s Guide. If you hav

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Picture this: It’s June 28, 2025, and you’re standing in a humming lab, cryogenic vapors swirling as a new quantum chip is lowered into its vacuum chamber. I’m Leo—the Learning Enhanced Operator—and today, quantum programming feels different. Not just for me, but for the entire field. Because just this week, the world’s headlines have been ablaze with news of breakthroughs that make quantum computers not only faster, but finally, actually easier to program and use.

Let’s get right to it: The team at the University of Osaka has shattered expectations with a new protocol for magic state distillation—a notoriously tricky cornerstone of fault-tolerant quantum computing. Why does this matter? Well, quantum computers draw their power from states like superposition and entanglement, but these same states are so fragile that even a stray whisper or flicker of light can cause catastrophic errors. To do real, “useful” quantum computing, we need error correction—and that always made our code slow, convoluted, and bloated with overhead.

But Osaka’s “level-zero distillation” turns this on its head. Imagine if you could prepare pristine magic states—quantum ingredients that unlock the most powerful gates—with a fraction of the resources. The researchers, including Tomohiro Itogawa and Keisuke Fujii, showed they could achieve high-fidelity states dozens of times faster, and with far fewer qubits, compared to old-school approaches. It’s like switching from laying each brick by hand to 3D printing an entire house in one go. This leap doesn’t just trim the fat from the code; it slashes hardware requirements and brings industrial-scale, noise-resistant quantum machines dramatically closer to reality.

And it’s not just Japan making waves. Quantinuum, working with UC Davis, just revealed code-switching techniques that connect two powerful error correction codes—demonstrating, for the first time, a universal gate set with live, repeatable quantum error correction. The kicker? This entire process cost only 28 qubits—down from hundreds. All the essential ingredients for a truly universal, fault-tolerant quantum computer are finally in place. Their new system, Helios, could soon be the most powerful quantum computer on the planet.

I find these developments echoing in today’s wider world. Just as quantum bits must dance in harmony through fragile, entangled states, so too must our societies adapt and evolve—balancing stability with innovation in the face of constant noise, whether from politics, climate, or AI revolutions.

Quantum programming is no longer an esoteric art; it’s becoming a practical, deployable technology. As I look at the blinking lights on our lab's quantum rack, I can almost hear the future humming in superposition.

Thank you for tuning in to Quantum Bits: Beginner’s Guide. If you have questions or want a topic discussed, send me an email at [email protected]. Remember to subscribe, and for

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

You know, there are days when working in quantum computing feels like standing on the edge of a new continent, peering out into fog-shrouded territory, wondering what civilizations and wonders lie just over the horizon. And then, every so often, the fog lifts all at once. That’s what this past week felt like—history unfolding in our labs and headlines.

I’m Leo—the Learning Enhanced Operator. Today on Quantum Bits: Beginner’s Guide, I’ll take you right to the heart of the latest breakthrough in quantum programming, and why recent global headlines from Google, Microsoft, and Quantinuum mark a real turning point in how we use these remarkable machines.

Now, skip the introductions—let’s zero in. On Tuesday, our Slack channels exploded with Google’s announcement: their Willow quantum processor, a 100-qubit superconducting chip, just achieved something I’ve only dreamed about since my grad school days. They managed “below-threshold” error correction. To put it more simply: by scaling their system from 9 to 49 encoded qubits, the Willow chip managed to halve the error rate at every step. Imagine teaching a choir of singers to stay in pitch not by replacing bad notes, but by doubling the number of singers—and each time, the collective sound gets crisper, more beautiful. In quantum terms, adding more qubits hasn’t just added more noise; it’s made the whole system more reliable. This is the first time in history that growing a quantum computer actually made the overall computation *more* trustworthy.

Let’s set the scene. Picture the Willow chip humming quietly in a room chilled to a fraction of a degree above absolute zero. Its qubits, fragile as soap bubbles, balanced delicately in superposition and entanglement. For years, we feared that adding more qubits would just multiply the errors—it’d be like trying to conduct a symphony in a hurricane. But this time, with each new section added to the orchestra, the storm receded, and the music became clearer. In a benchmark that would take a classical supercomputer longer than the lifespan of the universe—ten to the twenty-fifth years—Willow got it done in under five minutes, all while continually correcting its own mistakes on the fly.

But the quantum stage isn’t populated by lone heroes. In a dazzling display of collaboration, Quantinuum—born of Honeywell and Cambridge Quantum—joined forces with Microsoft, fusing their 32-qubit H2 trapped-ion processor with Microsoft’s cutting-edge error-correcting software. The result? Four logical qubits with error rates 800 times lower than the physical qubits that underpin them. That’s like building a skyscraper on quicksand, and engineering the foundation so perfectly that the building is steadier than if it were on bedrock.

Why does this matter for programming quantum computers? For one, the friction between a programmer’s creative intent and the machine’s reality—noise, decoherence, random flukes—has always been

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Imagine standing inside a chilled, humming laboratory—silver racks lined with spaghetti-like cables, the quiet pulse of helium cooling tanks, and at the center, a chip unlike any silicon you’ve ever held. My name is Leo, short for Learning Enhanced Operator, and this is Quantum Bits: Beginner’s Guide. Today, I’m sharing one of those moments when the quantum world leaps forward—right before our eyes.

This week, the halls of Google’s quantum lab crackled with energy. Scientists in white coats, notepads in hand, crowded around Willow, Google’s latest quantum processor. For years, quantum programming has lived under the shadow of one central challenge: errors. In the eerie realm of quantum mechanics, qubits are slippery—prone to vanishing information with a brush of heat or magnetic noise. But now, with Willow, everything changed. Google published in Nature that their new 100-qubit superconducting chip achieved what many had said was impossible: “below-threshold” error correction.

Let’s break that down. Classic computers flip between ones and zeros—like a light switch, on or off. Quantum bits, or qubits, shimmer in superposition: both one and zero at the same time. But as soon as you look, the whole fragile structure can collapse. Think of it like spinning a coin on a table. Qubits, like spinning coins, can drift—errors creep in. Our job as quantum programmers is to keep those qubits spinning perfectly, even as the world jostles the table.

Willow uses something called a surface code—imagine a patchwork quilt of interconnected qubits. Here’s the experiment: the team started with 9 encoded qubits, then scaled to 49, and up toward 100. With each increase, the error rate didn’t just inch down—it dropped exponentially, halving at every step. For the first time, making a quantum system bigger actually made it more reliable. They shattered the old rule that larger quantum systems would simply become noisier messes.

When they put Willow to the test, it ran a calculation in under five minutes. If you gave the same problem to the world’s fastest classical supercomputer, it would still be running when the sun burns out—roughly ten to the twenty-fifth power years. That’s not just fast. That’s a leap across the event horizon into a new era.

This was not a solo act. Just this month, Quantinuum—a collaboration between Honeywell and Cambridge Quantum—joined forces with Microsoft. Their hybrid quantum-classical system married Quantinuum’s trapped-ion processor with Microsoft’s new error-correcting software. The result? Four logical qubits whose error rates plunged eight hundred times below the raw error rate of the underlying hardware. That’s like upgrading from a rusty bicycle to a maglev bullet train overnight. Soon, you’ll be able to access this hybrid system right from Azure Quantum’s cloud.

Why is this such a big deal for you, the aspiring quantum programmer? Until now, quantum coding meant wrestling wi

This content was created in partnership and with the help of Artificial Intelligence AI.

This is your Quantum Bits: Beginner's Guide podcast.

Today, I want to pull you straight into the epicenter of quantum discovery—a story that’s still unfolding as we speak. Over the past few days, the hum in the labs across IBM’s Yorktown Heights campus has grown almost electric, and not just because of the cryostats chilling their new Nighthawk quantum processor down to near absolute zero. The latest announcement from IBM—a leap in quantum programming tools built on the launch of Nighthawk—has shaken up what we thought was possible with quantum computers, and it opens a new world of usability for programmers everywhere.

I’m Leo, Learning Enhanced Operator, and on Quantum Bits: Beginner’s Guide, my mission is to make those Newsweek covers and cryptic press releases not just comprehensible, but thrilling—because quantum is the adventure story of our time.

Let’s tackle the heart of this week’s breakthrough: IBM’s unveiling of advanced quantum programming tools designed for their Nighthawk processor, a marvel sporting 120 highly connected superconducting qubits. This isn’t just another hardware upgrade—it’s a revolution in how we interact with quantum machines.

Picture this: until now, programming a quantum computer often felt like sending Morse code to an alien spacecraft. The algorithms were fragile, every calculation haunted by the specter of quantum noise, errors, and decoherence. The complexity kept all but a tiny priesthood of quantum physicists out of the game.

But with Nighthawk, IBM has introduced modular, highly connected architecture that allows quantum circuits to be expressed in a more natural, flexible way. The new software tools now allow programmers to leverage high-performance classical computing alongside quantum resources—imagine a relay race where a quantum sprinter passes the baton to a classically-trained marathoner. This synergy doesn’t just speed things up, it makes programming feel intuitive, even graceful. By allowing for 5,000 two-qubit gates on 120 qubits, the toolset brings quantum programming tantalizingly close to what most developers expect from classical platforms. You get error-mitigation routines, circuit optimizers, and even visual debuggers—turning what was once a mystic art into a creative engineering discipline.

Now, why does this matter? Because it’s a pivotal step towards quantum advantage—the moment when quantum computers outperform the world’s best supercomputers at useful tasks. As of this week, tools built for Nighthawk are being released to the IBM Quantum Platform community, meaning researchers and businesses can experiment with more complex algorithms—molecular modeling, optimization, even AI—without being quantum wizards. They can focus on their problems, letting the platform handle the quantum weirdness underneath.

The ripple effect is immediate. At institutions from MIT to the University of Tokyo, quantum teams are racing to test machine learning models and cryptographic tools on Nighthawk. B

This content was created in partnership and with the help of Artificial Intelligence AI.