TL;DR

• Claude Mythos, Anthropic's frontier AI model, is now publicly available. It autonomously discovers software vulnerabilities at a scale no human security team can match.
• AI coding tools have expanded open source dependency footprints faster than most engineering teams can track, creating an unreviewed attack surface.
• Project Glasswing disclosed 1,596 vulnerabilities across 281 open source projects; only 97 were patched. Human triage is the bottleneck, not discovery.
• The median time from vulnerability discovery to working exploit has collapsed from 771 days in 2018 to under four hours today.
• The answer isn't slower development. It's a continuously maintained open source inventory that removes remediation toil without touching velocity.

Anthropic has confirmed that Claude Mythos, previously in restricted testing under Project Glasswing, is now publicly available. If you haven't followed the story closely, the short version is this: Mythos is a general-purpose frontier model whose reasoning and coding capabilities turned out to be exceptionally good at finding and exploiting software vulnerabilities. Not by design. As a side effect.

That distinction matters, because the same dynamic is already playing out in your engineering organization. The AI tools your developers use every day weren't designed to create governance problems either. That's just what happens when you optimize for speed without a corresponding system for what gets pulled in along the way.

How AI Coding Tools Create an Unreviewed Open Source Dependency Problem

For the last couple of years, AI coding tools have been the best thing to happen to engineering throughput. Developers ship faster. Prototypes become products in weeks. Teams do what used to require headcount they didn't have.

But AI-assisted development has a side effect most teams haven't fully priced in yet.

When AI writes code at speed, it pulls in unreviewed dependencies at speed. It scaffolds projects with packages, fills gaps with libraries, reaches for whatever is available and plausible. That's exactly what a good developer under deadline does, too. The difference is volume. AI doesn't slow down, doesn't flag uncertainty about a maintainer's responsiveness, or check whether a package was last updated two years ago. It suggests what compiles and ships.

Most engineering teams don't fully know what's running in production. They know what they explicitly chose, but they don't have clean visibility into what their AI tooling chose on their behalf, three levels deep in a transitive dependency chain.

Now a model like Mythos can scan that surface area and find exploitable vulnerabilities faster than any human researcher ever could, and critically, faster than most organizations can respond.

The Bottleneck Was Never Vulnerability Discovery. It's Remediation Capacity.

Here's what Project Glasswing's own data makes plain: as of late May, Anthropic had disclosed 1,596 vulnerabilities across 281 open source projects. Of those, 97 were known to be patched.

Read that again. Thousands of findings. Ninety-seven patches.

Anthropic explicitly identified independent human triage and review as the rate-limiting step. Not the AI. The humans on the other end of the queue.

Mythos didn't create this structural problem. It's just making it impossible to ignore. We've had scanners for years. The bottleneck is always the same: who fixes what when you find something?

Someone has to triage it. Someone has to determine whether it's exploitable in your specific environment. Someone has to figure out which team owns the affected component. Someone has to open a ticket, prioritize it against everything else in the sprint, test the fix, and ship it. In most organizations, that process takes weeks. Sometimes months. On some teams, it quietly doesn't happen at all.

The median time from vulnerability discovery to working exploit has collapsed from 771 days in 2018 to under four hours today, and is projected to hit under one hour by the end of 2026. That math doesn't work for organizations running quarterly security reviews and a remediation queue measured in sprints.

Why AI Coding Acceleration Creates a Hidden Remediation Backlog

The conversation I keep having with engineering leaders goes like this: they adopted AI coding tools to reclaim time. And they did. But they didn't account for the liability those tools were accumulating on their behalf.

So the equation looks like this: AI accelerates development, AI-scale vulnerability discovery accelerates risk exposure, and the engineering team is left holding a remediation queue that grows faster than they can clear it.

The productivity gains are real. But they're being offset by security toil that doesn't show up in velocity metrics, until it shows up in a board meeting or an incident.

What Changes Operationally When You Govern Your Open Source Inventory

The answer isn't to slow down AI-assisted development. That conversation is over.

It's to stop remediation from being a tax that lands in your team's backlog. When your package inventory is continuously maintained, your team is free to focus on shipping. No one is discovering they have a problem three sprints too late.

Here's what that looks like in practice. Instead of a scanner producing findings that land in a backlog with no clear owner, you work from a maintained open source inventory where provenance is known, risk is continuously assessed, and the fix path for a given component is already defined before a finding hits your queue. When a wave of new CVEs enters the ecosystem, which is exactly what Mythos-class discovery will produce at scale, your team isn't affected. Your components are clean and traceable.

Rather than another tool purchase, it's an operational posture for codebases developed via AI-assisted coding. At ActiveState, we work on this problem directly: building the infrastructure that gives engineering and security teams a clean, organization-wide inventory. The posture is the thing. The tooling is how you scale it.

Three Things Engineering Teams Should Do Now

Mythos is public. The preparation window is effectively closed. What's left is execution.

1. Get honest about what's actually in your environment. Not your declared dependencies. Your full transitive graph. If you can't answer that question today, you won't be able to triage at speed as findings arrive.
2. Define ownership before you're forced to. When a critical CVE drops against a package your team didn't consciously choose, who owns the response? If the answer is "it depends" or "we'd figure it out," that's a process gap that will cost you under pressure. Write it down now.
3. Stress-test your remediation cadence against a significantly higher volume of high-fidelity findings. HackerOne's platform data already shows vulnerability submissions up 76% year-over-year, with critical and high severity findings now at 32% of validated issues, up from 26-28% historically. Mythos going public didn't start that trend. It just accelerated it.

The teams that successfully absorb what's coming will have built the operational open source foundation before they needed it. That ensures AI-assisted gains aren't cancelled out by unintended security toil and unplanned incidents.

Rebecca Banks is Senior Product Marketing Manager at ActiveState, where she leads go-to-market strategy for software supply chain security. She is currently a contributor to the Linux Foundation and OpenSSF 2026 AI Security Study on global AI coding security maturity for enterprises and critical infrastructure organizations.