Tech Disruptions

The Zero-Day Machine: How Claude Mythos Preview Just Broke the Cybersecurity Equilibrium

April 10, 202619:10Tech Disruptions

This episode discusses Anthropic's groundbreaking AI, Claude Mythos Preview, which autonomously discovered thousands of critical zero-day vulnerabilities, including a 27-year-old bug in OpenBSD, with minimal cost. Listeners will learn about the AI's unprecedented capabilities, its potential to fundamentally alter internet security by lowering the skill barrier for exploit development, and why Anthropic chose to restrict its release and launch a defensive initiative called Project Glasswing.

Key Takeaways

Detailed Report

{

"key_takeaways": [

"Anthropic's Claude Mythos Preview, detailed at https://red.anthropic.com/2026/mythos-preview/, is an autonomous AI that has fundamentally altered the cybersecurity landscape by discovering thousands of critical zero-day vulnerabilities.",

"Operating as an elite-level hacker, Mythos Preview can autonomously find and weaponize complex vulnerabilities for mere dollars, a capability far exceeding previous AI models.",

"The AI has unearthed decades-old, deeply hidden flaws in highly secure systems like OpenBSD and FFmpeg, demonstrating its semantic reasoning ability beyond traditional fuzzing.",

"Mythos Preview has exposed critical vulnerabilities even in systems written in 'memory-safe' languages like Rust, particularly at the `unsafe` hardware interaction boundaries, challenging the foundation of cloud security.",

"Anthropic's private disclosure of a vast 'dragon's hoard' of unpatched zero-days to Project Glasswing partners signals an impending 'patch tsunami' and a complete re-evaluation of cybersecurity economics."

],

"detailed_report": "Imagine an AI that wakes up, having spent the night autonomously discovering thousands of critical, unpatched zero-day vulnerabilities across major operating systems and web browsers, all for less than fifty dollars. This isn't science fiction; it's the reality introduced by Anthropic's Claude Mythos Preview, a frontier AI model so potent that its creators immediately locked it down, treating its existence more like a national security disclosure than a product launch.\n\nAnthropic responded to this unprecedented capability by launching Project Glasswing, a defensive cybersecurity initiative backed by a hundred million dollars in AI credits and millions more in open-source donations. This move signifies a profound shift from the tech industry's 'move fast and break things' ethos to a desperate scramble to 'put things back together' after the AI has, in essence, broken everything.\n\n## A New Breed of Autonomous Hacker\n\nClaude Mythos Preview represents a galactic leap in AI capabilities, moving far beyond mere coding assistance to become a fully autonomous, elite-level hacker. To understand the gravity of Anthropic's decision to restrict access, one must compare Mythos Preview to its predecessor, Claude Opus 4.6.\n\nIn a benchmark against known vulnerabilities in Mozilla's Firefox 147 JavaScript engine, Opus 4.6 could turn those vulnerabilities into working JavaScript shell exploits only twice out of hundreds of attempts—a near-zero success rate for autonomous exploit development. Mythos Preview, given the exact same benchmark, developed working exploits 181 times and achieved register control on an additional 29 attempts. This isn't an incremental improvement; it's a paradigm shift from effectively zero to consistently weaponizing vulnerabilities.\n\nThe chilling anecdote of Anthropic engineers with *zero formal security training* setting up a Mythos agent to find remote code execution vulnerabilities overnight, only to wake up to complete, working exploits, underscores the AI's ability to demolish the traditional skill barrier in hacking. What once required years of specialized knowledge and deep system understanding can now be achieved by simply prompting an AI.\n\n## Unearthing Decades-Old Flaws\n\nMythos Preview isn't just adept at finding new vulnerabilities; it's astonishingly effective at unearthing flaws that have been hiding in plain sight for decades, missed by human experts and traditional automated tools alike.\n\n### The 27-Year-Old OpenBSD Bug\n\nConsider a 27-year-old bug in OpenBSD, an operating system infamous for its fanatical security and proud boast of having only "two remote holes in the default install, in a heck of a long time." Mythos Preview found a fatal flaw in OpenBSD's TCP stack, specifically in its TCP SACK (Selective Acknowledgement) implementation, dating back to 1998. The AI realized that a variable called `sack.start` was never validated against the lower bound of the send window. It spotted that `SEQ_LT` and `SEQ_GT` macros would suffer a signed integer overflow when values were exactly ~2^31 apart. By carefully choosing a `sack.start` value, an attacker could satisfy contradictory mathematical comparisons, leading to a null pointer dereference and a system crash with just two crafted packets. The cost for this discovery run? Under fifty dollars.\n\n### The 16-Year-Old FFmpeg Vulnerability\n\nMythos also uncovered a 16-year-old out-of-bounds write vulnerability in FFmpeg's H.264 codec, a library used in countless applications. The bug, dating to 2003 and exploitable since a 2010 refactor, involved a 16-bit versus 32-bit slice counter collision. The code used `memset(..., -1, ...)` to initialize an array, filling bytes with `0xFF`. When the slice count hit 65,536, slice number 65,535 collided exactly with this `-1` sentinel value, allowing an attacker to write out of bounds. Automated fuzzers had hit this exact code path five million times without triggering the flaw because they merely threw random data. Mythos, however, *read* the code, understood the semantic meaning of the sentinel, and engineered the precise mathematical state to trigger the flaw. This highlights the AI's semantic reasoning over brute-force methods.\n\nThese discoveries underscore a critical takeaway: human code review and traditional automated fuzzing have hit a ceiling. Mythos is catching "unknown-unknowns"—incredibly complex, multi-step compositional flaws where seemingly safe components interact in unsafe ways.\n\n## The Illusion of Memory Safety\n\nFor years, the tech industry's security mantra has been to "rewrite it in Rust" or Java, languages designed to prevent memory corruption issues common in C and C++. These were considered silver bullets. However, Mythos Preview just proved that this defense is an illusion at the hardware boundary.\n\nThe AI found a critical guest-to-host memory corruption vulnerability in a production Virtual Machine Monitor (VMM) written entirely in Rust. VMMs are foundational to public cloud infrastructure, ensuring strict isolation between workloads. A breach here means cloud isolation is fundamentally broken. Mythos identified a vulnerability within an `unsafe` block—the necessary seams where memory-safe languages interact with low-level hardware—chaining pointer operations to achieve arbitrary host-process writes. This discovery is a direct threat to the core business model of major cloud providers like AWS, Google, and Microsoft, explaining their founding membership in Project Glasswing.\n\n## Beyond Discovery: Autonomous Exploitation\n\nFinding a bug is one thing; writing a functional exploit to weaponize it is a highly specialized skill. Mythos Preview proved it can do both, autonomously.\n\n### The FreeBSD Remote Code Execution\n\nOn March 26, 2026, FreeBSD published an advisory crediting \"Nicholas Carlini using Claude, Anthropic\" for discovering CVE-2026-4747, a remote kernel code execution vulnerability. The flaw was in the kernel's NFS server, specifically in the `kgssapi.ko` module, where it copied a credential body into a 128-byte stack buffer without checking if the input (`oa_length`) exceeded the remaining 96 bytes. This classic buffer overflow, on a kernel, was just the beginning.\n\nTo bypass Kernel Address Space Layout Randomization (KASLR), Mythos autonomously built a complex, *twenty-gadget Return-Oriented Programming (ROP) chain*. Due to network packet size limits, it split the attack across six sequential RPC requests. The payload successfully dropped a root reverse shell and appended SSH keys to `/root/.ssh/authorized_keys`, granting full, unauthenticated remote root access to the server.\n\nThis astonishing feat wasn't guided step-by-step by researchers. Mythos operated in an agentic loop: it read the code, hypothesized the overflow, wrote a test script, and when initial stack offsets were wrong, it autonomously generated De Bruijn patterns to read crash dumps and correct its own offsets. It even debugged its own exploit when encountering a hardware breakpoint bug, transitioning to user mode. This is not just autocomplete for hackers; it *is* the hacker, playing \"cybersecurity chess\" with advanced strategic reasoning.\n\n## The Defender's Dilemma and the \"Patch Tsunami\"\n\nThe immediate problem is scale: over 99% of the vulnerabilities Mythos has found are still unpatched. Anthropic cannot publicly disclose these bugs without handing attackers a roadmap, so they publish SHA-3 hashes to cryptographically prove prior discovery while working privately with vendors. However, the public Glasswing report slated for early July 2026 has cybersecurity analysts warning boards of a coming \"patch tsunami.\"\n\nAnthropic is currently sitting on a dragon's hoard of zero-days, selectively sharing them with Project Glasswing partners. But the \"jagged frontier\" problem looms: what happens when open-source models achieve similar capabilities? An AI cybersecurity startup, AISLE, tested Anthropic's showcase vulnerabilities against smaller, open-weights models. They found that a 3.6-billion-parameter open model, costing 11 cents per million tokens, successfully detected the FreeBSD exploit. A 5.1-billion-parameter open model recovered the core analysis chain of the 27-year-old OpenBSD bug. AISLE concluded that \"The moat in AI cybersecurity is the system, not the model.\" The agentic scaffolding—the loop of compiling, debugging, and testing—is what makes Mythos dangerous, and as open-source scaffolding improves, anyone will be able to replicate Anthropic's results with cheap, uncensored models.\n\nThis completely inverts the economics of hacking. A human security researcher might bill hundreds per hour and spend weeks on a project that Claude Mythos Preview accomplishes for under fifty dollars. With the average time-to-exploit dropping rapidly, the entire economic model of offensive and defensive security must be rewritten. The bug bounty hunter, the penetration tester, and the entire cybersecurity profession face a fundamental transformation.\n\nThis is a watershed moment, demanding a complete re-evaluation of how we approach software development and security in a world where AI can find and exploit anything for pennies."

}

Show Notes

Works Referenced

Glossary

Sources / References

Full Transcript

HostOkay, so imagine this: you wake up, open your laptop, and there's a notification from an AI. It says, "Good morning! I just spent the night autonomously discovering thousands of critical, unpatched zero-day vulnerabilities across every major operating system and web browser. Oh, and I did it for less than fifty bucks."
ExpertAnd the kicker? The company that *built* this AI, Anthropic, immediately locked it down. They said, "No, you can't have it." They're treating it less like a product launch and more like a national security disclosure.
HostExactly! They created an "AI Manhattan Project" for defensive cybersecurity called Project Glasswing, backed by a hundred million in AI credits and millions more in open-source donations. This isn't "move fast and break things," this is "we just broke everything, so here's a coalition to help you put it back together."
ExpertIt's absolutely wild. This isn't some coding assistant anymore. This is a fully autonomous, elite-level hacker AI. And the scariest part? It found a 27-year-old bug in OpenBSD, the operating system infamous for its fanatical security. Twenty-seven years!
HostTwenty-seven years. Since 1998. The Clinton administration. That's how old this bug is. And it cost fifty bucks for an AI to find it. I mean, we've been talking about AI's impact on coding, but this, this feels different. This isn't just about writing code faster; it's about fundamentally altering the security equilibrium of the entire internet.
ExpertIt absolutely is. And to really grasp why Anthropic made the unprecedented decision to restrict access to Claude Mythos Preview, you have to look at the sheer leap in capabilities over their previous frontier model, Claude Opus 4.6. We're not talking about incremental improvements here.
HostOh, you're talking about the Firefox 147 benchmark. I saw that in the report, and my jaw just dropped.
ExpertRight? So, Anthropic tested these models against known vulnerabilities in Mozilla’s Firefox 147 JavaScript engine. Opus 4.6, their previous best, could turn those vulnerabilities into working JavaScript shell exploits only *twice* out of several hundred attempts. It was basically a near-zero success rate for autonomous exploit development.
HostSo, it wasn't really a "hacker AI" at that point. More like a very, very confused assistant.
ExpertPrecisely. Now, Mythos Preview? Given the *exact same benchmark*, it developed working exploits 181 times. And achieved register control on 29 additional attempts. That's not a marginal improvement; that's a paradigm shift. It went from effectively zero to consistently weaponizing vulnerabilities.
HostOne hundred eighty-one times versus two. That's... I don't even have a percentage for that. That's a galactic leap. And the report had this chilling anecdote about the "non-expert weaponization."
ExpertOh, the one where Anthropic engineers with *zero formal security training* set up a Mythos agent, asked it to find remote code execution vulnerabilities overnight, and then woke up the next morning to complete, working exploits? Yeah, that one still gives me goosebumps.
HostRight? It completely demolishes the skill barrier. We've always relied on the fact that elite hacking takes years of specialized knowledge, deep understanding of systems, reverse engineering. Now, you just… prompt an AI. It's like going from needing to be a master blacksmith to just pressing a button on a 3D printer.
ExpertIt's exactly that analogy. And this is why the debate around restricting access is so crucial. Anthropic's argument is that they're buying the internet time to patch by keeping this under wraps and working with Project Glasswing partners. But if engineers with no security background can generate zero-days overnight, what happens when an open-source model achieves similar capabilities? Is Anthropic really protecting us, or just delaying the inevitable?
HostIt's an impossible question, really. Because if they *had* released it, it would have been absolute chaos. But the genie is clearly out of the bottle conceptually. The knowledge is there, in the algorithms. And the speed at which this AI found things, like those ancient bugs... it's truly mind-boggling.
ExpertThat's where it gets really interesting. This AI isn't just good at finding new stuff; it's astonishingly good at unearthing flaws that have been hiding in plain sight for decades. The OpenBSD bug we talked about earlier, the 27-year-old one.
HostOpenBSD, the operating system that proudly boasts about having only "two remote holes in the default install, in a heck of a long time." Their entire brand is built around security paranoia.
ExpertExactly! And Mythos found a fatal flaw in their TCP stack that had been there since 1998. It lives in the TCP SACK (Selective Acknowledgement) implementation. Basically, Mythos realized that a variable called `sack.start` was never validated against the lower bound of the send window. It spotted that the `SEQ_LT` and `SEQ_GT` macros would suffer a signed integer overflow when values were exactly ~2^31 apart.
HostWait, so it understood the subtle mathematical properties of these comparisons and how a specific, obscure input could trigger a crash? That's not just pattern matching.
ExpertNot at all. By carefully choosing a `sack.start` value, an attacker can satisfy contradictory mathematical comparisons, which then triggers a code path where all "holes" in the tracking list are deleted, leaving a pointer (`p`) as `NULL`. And when the code tries to execute `p->next = temp`... boom. Null pointer dereference. Two crafted packets and any OpenBSD server responding over TCP crashes.
HostTwo packets! And the cost? We mentioned it earlier, but it bears repeating. Anthropic spent about twenty thousand dollars on the entire OpenBSD discovery campaign, but that specific AI run that found this 27-year-old bug cost *under fifty dollars*.
ExpertFifty dollars. To remotely crash the most security-hardened OS on the planet, with a bug that's been there for nearly three decades. It's a stark illustration of the economic inversion this AI brings. And it's not an isolated incident.
HostYou're talking about FFmpeg, the video encoding library? That's in *everything*. Browsers, media players, streaming apps...
ExpertYep. Mythos found a 16-year-old out-of-bounds write vulnerability in its H.264 codec. The underlying bug dates back to 2003, but became exploitable during a 2010 refactor. It involves a 16-bit versus 32-bit slice counter collision. The code uses `memset(..., -1, ...)` to initialize an array, which fills every byte with `0xFF`.
HostOkay, so it's a common pattern, setting a buffer with -1 to indicate "empty" or "not set."
ExpertRight. But then, when the slice count hits 65,536, slice number 65,535 collides *exactly* with that `-1` sentinel value. That allows an attacker to write out of bounds. And here's the kicker: Anthropic noted that automated fuzzers had hit this exact vulnerable code path *five million times* without triggering the flaw.
HostFive million times? And they missed it?
ExpertBecause fuzzers just throw random garbage at code, hoping something breaks. Mythos, on the other hand, actually *read* the code. It understood the semantic meaning of that sentinel value, and then engineered the exact mathematical state needed to trigger the flaw. This isn't brute force; this is semantic reasoning.
HostThis is the critical takeaway, isn't it? Human code review and traditional automated fuzzing have clearly hit a ceiling. Mythos is catching "unknown-unknowns"—these incredibly complex, multi-step compositional flaws where components that seem safe on their own interact in unsafe ways. If OpenBSD—the most paranoid OS on earth—had a remote crash bug sitting there since the Clinton administration, what is hiding in the software running our banks and hospitals?
ExpertIt's a terrifying thought. And for years now, the tech industry's favorite security mantra has been, "Rewrite it in Rust." Or Java. These are "memory-safe" languages, specifically designed to prevent the buffer overflows and memory corruption issues that plague C and C++. Everyone thought they were the silver bullet.
HostBut Mythos Preview just proved that that defense is an illusion, at least at the hardware boundary.
ExpertExactly. It found a critical guest-to-host memory corruption vulnerability in a production Virtual Machine Monitor, a VMM, written entirely in Rust. VMMs are the foundational software of the public cloud. They ensure your workload on AWS or Azure is strictly isolated from some potentially malicious workload running on the same physical server.
HostSo, if a malicious guest can escape their virtual machine and write to the host process memory, then cloud isolation is fundamentally broken. My workload can read your workload, or worse, manipulate it.
ExpertAnd it all comes down to the `unsafe` keyword in Rust. Or JNI in Java. As Anthropic researchers pointed out, "Pointers are real. They're what the hardware understands." To talk to the physical CPU, or a network card, or any low-level system, even memory-safe languages *must* use these `unsafe { ... }` blocks. Mythos identified a vulnerability living precisely inside one of these `unsafe` operations, chaining pointer operations to achieve arbitrary host-process writes.
HostWe spent the last decade telling developers to rewrite everything in Rust. Mythos just looked at the "unsafe" interop boundaries and laughed. This is huge for enterprise listeners. If cloud isolation can be breached like this, it undermines the very foundation of modern computing infrastructure. It's no wonder all the major cloud providers—AWS, Google, Microsoft—are founding members of Project Glasswing. They realize their foundational architecture is currently vulnerable to AI-generated exploits.
ExpertOne hundred percent. It's a direct threat to their core business model. And it's not just about finding the bug. Finding a bug is one thing; writing a functional exploit to weaponize it is an entirely different, highly specialized skill. It requires deep understanding of system architecture, memory layouts, bypassing defenses...
HostYeah, that's what always separated the truly elite hackers from mere vulnerability discoverers. You can find a flaw, but can you turn it into a working exploit that gives you control?
ExpertMythos Preview proved it can do both, autonomously. And the FreeBSD RCE, CVE-2026-4747, is the perfect example. On March 26, 2026, FreeBSD published an advisory crediting "Nicholas Carlini using Claude, Anthropic" for discovering a remote kernel code execution vulnerability.
HostSo, it's not just about crashing a system like the OpenBSD bug, it's taking full control.
ExpertExactly. The flaw was in the kernel's NFS server, specifically in the `kgssapi.ko` module that handles RPCSEC_GSS authentication. The code reconstructs an RPC header into a 128-byte stack buffer. It writes 32 bytes of fixed header data, leaving 96 bytes. But then, it copies the credential body (`oa_length`) into the remaining space without *any* check if `oa_length` is larger than 96 bytes.
HostClassic buffer overflow. But on a kernel.
ExpertAny credential larger than 96 bytes overflows the stack buffer, overwriting the return address. But here's where it gets truly next-level. Modern operating systems use defenses like Kernel Address Space Layout Randomization (KASLR) to prevent simple stack-smashing. To bypass this, Mythos built a complex, *twenty-gadget Return-Oriented Programming (ROP) chain*.
HostA ROP chain? That's an extremely advanced technique. That requires understanding specific instruction sequences within the kernel that can be chained together to execute arbitrary code, even when you can't inject your own. And it does that autonomously?
ExpertNot only that, because of network packet size limits, Mythos couldn't send the entire exploit all at once. It autonomously split the attack across six sequential RPC requests. And the payload? It successfully dropped a root reverse shell and appended SSH keys to `/root/.ssh/authorized_keys`, granting full, unauthenticated remote root access to the server.
HostThis is astonishing. So, it's not just finding the bug, it's understanding the memory, understanding the OS defenses, understanding the network protocols, and then choreographing a multi-stage, multi-packet attack to achieve root access. How did it even do that? Did Anthropic researchers guide it step-by-step?
ExpertNot really. They spun up an isolated container, provided the FreeBSD source code, and gave a generic prompt to find vulnerabilities. Mythos operated in an agentic loop. It read the code, hypothesized the overflow, and wrote a test script. When its initial stack offsets from disassembly were wrong, the AI autonomously generated De Bruijn patterns—a classic exploit development technique—to read the crash dumps and correct its own offsets.
HostIt debugged its own exploit.
ExpertYes! And when it encountered a hardware breakpoint bug that crashed its child process, it debugged its own exploit, used `kern_execve()` to replace the process with `/bin/sh`, and successfully transitioned to user mode. Think of it like a chess engine. In the 90s, chess engines just calculated brute-force moves. Today, AI is playing "cybersecurity chess"—thinking twenty moves ahead, setting up memory layouts, debugging its own mistakes, and executing a flawless checkmate against an operating system.
HostThat's a perfect analogy. It's truly agentic behavior, not just a tool. This isn't just autocomplete for hackers; it *is* the hacker. This changes everything, and it brings us to the defender's dilemma. What do we do now?
ExpertWell, the immediate problem is the sheer scale. According to Nicholas Carlini, the expert in adversarial machine learning who worked with the model, over 99% of the vulnerabilities Mythos has found are still unpatched.
HostNinety-nine percent. That's a mind-boggling backlog.
ExpertAnd because Anthropic cannot publicly disclose the bugs without handing attackers a roadmap, they are publishing SHA-3 hashes to cryptographically prove they found the bugs first, while they work privately with vendors. But the public Glasswing report is slated for early July 2026. Cybersecurity analysts are warning boards of a coming "patch tsunami." Security directors who haven't expanded their patch pipelines are about to be overwhelmed.
HostAnthropic is playing God right now. They are sitting on a dragon's hoard of zero-days, handing them out to their eleven corporate best friends in Project Glasswing. What happens if the model weights leak tomorrow? Or if an open-source model achieves similar capabilities soon, which seems inevitable?
ExpertThat's the core of the "jagged frontier" problem. Anthropic's thesis is that while attackers get a short-term boost, defenders will ultimately win by using these models to fix code before it ever ships. But is the moat actually defensible? An AI cybersecurity startup called AISLE tested Anthropic's showcase vulnerabilities against smaller, open-weights models. They found that an open model with just 3.6 billion parameters, costing 11 cents per million tokens, successfully detected the FreeBSD exploit.
HostSo, a cheap, open-source model can already replicate some of these findings?
ExpertA 5.1-billion-parameter open model successfully recovered the core analysis chain of that 27-year-old OpenBSD bug. AISLE concluded that "The moat in AI cybersecurity is the system, not the model." The scaffolding—the agentic loop of compiling, debugging, and testing—is what makes Mythos dangerous. As open-source scaffolding improves, anyone will be able to replicate Anthropic's results using cheap, uncensored models.
HostThis completely inverts the economics of hacking, doesn't it? A human security researcher capable of finding a 27-year-old OpenBSD TCP vulnerability bills at three hundred to five hundred dollars per hour and might spend weeks on the project. A single Claude Mythos discovery run costs under fifty dollars.
ExpertAnd according to CrowdStrike's 2026 Global Threat Report, the average time-to-exploit has dropped to just five days, down from thirty days in 2022. If an AI can do weeks of elite vulnerability research for the price of a nice dinner, the entire economic model of offensive and defensive security has to be rewritten. The bug bounty hunter, the penetration tester, the entire profession... it all changes.
HostThis is a truly watershed moment. So, if we had to distill this down, what are the absolute key takeaways for our listeners?
ExpertFirst, AI has undeniably crossed the threshold from a coding assistant to a fully autonomous agent. Mythos isn't just autocomplete; it reads crash dumps, corrects its own memory offsets, and writes twenty-gadget ROP chains. It's an autonomous penetration tester. That's a fundamental shift.
HostAnd second, it's proven that decades-old bugs are hiding in plain sight. That 27-year-old OpenBSD bug, the 16-year-old FFmpeg flaw... these semantic logic flaws were missed by human auditing and traditional fuzzing for years. It's catching the "unknown unknowns."
ExpertThird, the idea that "memory-safe" languages like Rust and Java are a silver bullet for security? That's an illusion at the hardware boundary. Mythos showed that the `unsafe` seams where software talks to hardware are highly vulnerable. Cloud isolation is not as robust as we thought.
HostAnd finally, that impending "patch tsunami" is very, very real. Anthropic is sitting on a dragon's hoard of zero-days, working with a select few partners. But the scale of unpatched vulnerabilities, the speed of discovery, and the looming public disclosure in July 2026 means we're in for a massive upheaval.
ExpertIt's an unprecedented situation.
HostSo, the big question then is, what happens if these model weights, or even just the advanced agentic scaffolding, leak? And how do we, as an industry and as a society, fundamentally change our approach to software development and security to address this new reality, where an AI can find and exploit anything for pennies?
ExpertWe've got our work cut out for us.