Introduction

In a groundbreaking collaboration, the Firefox team partnered with Anthropic to deploy frontier AI models—first Opus 4.6 and later a preview of Claude Mythos—to systematically uncover latent security vulnerabilities in the browser. The result? A jaw-dropping 271 zero-day bugs identified in Firefox 150, on top of 22 earlier fixes in Firefox 148. This achievement demonstrates that AI can give defenders a decisive advantage—but only if teams know how to harness it effectively. This guide walks you through the exact process your team can follow to replicate this success, from establishing partnerships to patching vulnerabilities at scale. Whether you're a security lead, a DevOps engineer, or a CTO, these steps will help you turn the vertigo of overwhelming findings into a clear path toward a more secure product.

What You Need

• Access to a frontier AI model (such as a preview version of Claude Mythos or a similar advanced LLM trained on security data)
• An established collaboration with an AI lab or vendor (e.g., Anthropic, OpenAI, or Google DeepMind) that provides early access and support
• A dedicated security team capable of triaging, validating, and patching vulnerabilities quickly (at least 5–10 engineers for a large codebase)
• A continuous integration/deployment (CI/CD) pipeline to push patches rapidly to users
• Strong communication channels between the AI team and your security engineers
• A prioritization framework (e.g., critical/red-alert bugs handled first) to manage a surge of findings
• Time and focus to reprioritize other tasks for the duration of the campaign (typically weeks to months)

Step-by-Step Guide

Step 1: Establish a Partnership with an AI Lab

Before you can scan anything, you need access to cutting-edge AI models—often only available through early access programs or direct collaborations. The Firefox team partnered with Anthropic, first using Opus 4.6 and later an early preview of Claude Mythos. Reach out to leading AI labs, explain your security goals, and propose a joint evaluation. Most labs are eager to demonstrate the defensive potential of their models. Formalize an agreement that includes data-sharing protocols, model access, and regular sync meetings.

Step 2: Prepare Your Codebase for AI Scanning

Ensure your source code is clean, well-documented, and accessible to the AI model. This may involve:

• Structuring the codebase with clear module boundaries
• Removing any proprietary or sensitive information that shouldn't be shared (or use anonymization)
• Providing context to the model about common vulnerability patterns (e.g., buffer overflows, use-after-free, XSS)
• Setting up a secure integration so the model can analyze the code without exposing it to unnecessary risks

Firefox’s work spanned months, so plan for iterative scanning cycles rather than a one-shot analysis.

Step 3: Run the AI Model on Your Codebase

Deploy the frontier AI model to scan your code for vulnerabilities. In the Firefox case, Claude Mythos was applied to the entire codebase, producing a large list of potential bugs. The model may output a mix of true zero-days, duplicates, and false positives. Key considerations:

• Run multiple passes to capture different types of vulnerabilities
• Use the model’s ability to reason about complex interactions (e.g., race conditions, memory safety issues)
• Document the findings in a structured format (e.g., CVE-like entries with severity, location, and proposed fix)

Step 4: Triage and Validate Findings

This is where the real work begins. The first batch from the Firefox team with Opus 4.6 resulted in 22 security-sensitive bugs—a manageable number. But with Claude Mythos, the tally jumped to 271 vulnerabilities. Your team will need a rigorous triage process:

• Severity rating: Red-alert (critical) bugs require immediate attention. In 2025, even a single such bug would have triggered a red alert.
• Reproducibility: Verify each finding by creating a proof-of-concept or adding a test case.
• False positive filtering: Use static analysis tools and manual review to filter out non-issues.
• Assignment: Assign each validated bug to a developer with the right expertise (e.g., JavaScript engine for Firefox).

The sheer volume may cause “vertigo” (as the Firefox team described), but methodical triage turns chaos into action.

Step 5: Patch Vulnerabilities in Priority Order

With a prioritized list, begin fixing bugs. The Firefox example shows that reprioritizing everything else to focus single-mindedly on patching is essential. Steps:

1. Fix critical bugs first—these are the ones that could be exploited in the wild.
2. Develop patches that are minimal and safe to avoid introducing new issues.
3. Write regression tests to ensure the fix sticks.
4. Code review within the security team to catch errors.

For Firefox, patches were rolled into releases: Firefox 148 fixed 22 bugs, and Firefox 150 fixed the 271 from Claude Mythos. Aim to batch fixes into regular release cycles when possible, but be prepared for out-of-band emergency patches.

Step 6: Push Patches to Users Quickly

Speed matters. The AI advantage only works if defenders can patch faster than attackers can exploit. Ensure your CI/CD pipeline can:

• Build, test, and deploy updates within days (Firefox’s release cadence is typically every 4 weeks).
• Notify users to update (via auto-update mechanisms).
• Monitor for any regressions post-release.

In the article, the authors note: “Assuming the defenders can patch, and push those patches out to users quickly, this technology favors the defenders.” Make that assumption a reality.

Step 7: Iterate and Expand

The work doesn’t stop after one campaign. The Firefox team continues to apply AI to find more bugs. Set up a feedback loop:

• Provide the AI model with new code changes to scan continuously.
• Share findings with the AI lab to improve the model’s accuracy (e.g., reducing false positives).
• Scale the approach to other parts of your product (e.g., mobile apps, backend services).

As the article states: “Our work isn’t finished, but we’ve turned the corner and can glimpse a future much better than just keeping up.”

Tips for Success

• Embrace the vertigo. When you first see hundreds of potential zero-days, it’s overwhelming. Accept that feeling and then methodically work through the list—focus on what you can control.
• Reprioritize everything. During the intense scanning and patching phase, pause non-critical projects. The Firefox team redirected all resources to this task, and you may need to do the same.
• Communicate with leadership. The volume of bugs can alarm stakeholders. Explain that this is a sign of progress: you’re finding issues before attackers do. Frame it as a victory for defense.
• Build a shared ownership culture. Security is not just the security team’s job—every developer should understand they may need to fix vulnerabilities quickly.
• Partner early with AI labs. Early access to models like Claude Mythos gives you a head start. Don’t wait for public releases; seek out collaborations now.
• Celebrate wins. Every bug fixed is a bullet dodged. Recognize your team’s effort—they rose to the challenge, just as Firefox’s team did.

By following these steps, your organization can turn AI-powered vulnerability discovery from a theoretical promise into a practical, game-changing advantage. The defenders finally have a chance to win decisively.