ATLANTIS: AI-driven Threat Localization, Analysis, and Triage Intelligence System

Woosun Song (PhD Student · Georgia Tech)

POC2025 (Power of Community) · Main Stage

Overview

In a groundbreaking presentation at POC, Woosun Song from Georgia Tech unveiled ATLANTIS (AI-driven Threat Localization, Analysis, and Triage Intelligence System), the triumphant solution developed by Team Atlanta, the winning team of the prestigious DARPA AI Cyber Challenge (AIxCC). This talk provided an in-depth look into the architecture, methodologies, and key insights gained from a two-year effort that culminated in a $4 million prize and a significant leap forward in automated cybersecurity. ATLANTIS represents a paradigm shift, demonstrating how artificial intelligence can not only discover complex vulnerabilities but also generate patches and assess static analysis findings with unprecedented efficiency and accuracy.

Watch on YouTube · Slides

Visual summary for ATLANTIS: AI-driven Threat Localization, Analysis, and Triage Intelligence System by Woosun Song
Visual summary for ATLANTIS: AI-driven Threat Localization, Analysis, and Triage Intelligence System by Woosun Song

Key moments

  1. 0:46 AI Cyber Challenge (AIC): CTF for AI systems
  2. 8:00 18 zero-days found; $152 average cost per bug
  3. 10:00 ATLANTIS architecture: diversity and complementary specialization
  4. 18:00 LLMs generate fuzzing scripts for robustness and insight
  5. 21:40 Sanitizer-specific domain knowledge in prompts improved accuracy
  6. 24:00 Example of a complex SQLite use-after-free zero-day
  7. 26:00 AI is a double-edged sword for security and attackers
  8. 28:10 Q&A: LLMs generate fuzzing scripts to bypass PoC rejection

ATLANTIS: AI-driven Threat Localization, Analysis, and Triage Intelligence System

Speakers: Woosun Song (PhD Student, Georgia Tech)

Conference: POC

YouTube: https://www.youtube.com/watch?v=DVaaEDuDvcc

Overview

In a groundbreaking presentation at POC, Woosun Song from Georgia Tech unveiled ATLANTIS (AI-driven Threat Localization, Analysis, and Triage Intelligence System), the triumphant solution developed by Team Atlanta, the winning team of the prestigious DARPA AI Cyber Challenge (AIxCC). This talk provided an in-depth look into the architecture, methodologies, and key insights gained from a two-year effort that culminated in a $4 million prize and a significant leap forward in automated cybersecurity. ATLANTIS represents a paradigm shift, demonstrating how artificial intelligence can not only discover complex vulnerabilities but also generate patches and assess static analysis findings with unprecedented efficiency and accuracy.

The core of ATLANTIS lies in its innovative approach to leveraging large language models (LLMs) and diverse bug-finding strategies to automate the entire vulnerability lifecycle. Unlike traditional cybersecurity efforts that rely heavily on human expertise and manual analysis, ATLANTIS showcased an end-to-end system capable of analyzing codebases, identifying zero-day vulnerabilities, and providing concrete fixes in a fraction of the time and cost. The system's success in a highly competitive environment against other leading AI systems underscores the immense potential of AI to augment and transform defensive cybersecurity operations, setting a new benchmark for what autonomous systems can achieve in the realm of software security.

This article delves into the technical intricacies of ATLANTIS, exploring its design principles, the challenges it addressed, and the profound implications it holds for the future of cybersecurity. From its Kubernetes-based architecture to its sophisticated LLM-driven fuzzing techniques and iterative refinement processes, ATLANTIS offers a compelling vision of AI as a powerful ally in the constant battle against software vulnerabilities.

Background

▶ Watch: AI Cyber Challenge (AIC): CTF for AI systems (0:46)

The AI Cyber Challenge (AIxCC), a joint initiative by DARPA and ARPA-H, served as the ultimate proving ground for ATLANTIS. Building upon the legacy of the DARPA Cyber Grand Challenge (CGC), which focused primarily on exploit generation, AIxCC introduced a crucial new dimension: the ability for AI systems to patch vulnerabilities. This shift mandated a more comprehensive approach to automated security, encompassing not just discovery but also remediation.

The competition comprised three primary tasks:

  1. Vulnerability Discovery: A classical Capture The Flag (CTF)-style challenge to identify bugs.
  2. Program Repair: Providing a unified diff source code fix for discovered vulnerabilities. Notably, teams could submit a patch based on pure speculation without a proof of vulnerability, though this carried significant risk of point deductions for false positives or SLA breaches.
  3. SARIF Assessment: Analyzing SARIF (Static Analysis Results Interchange Format) outputs from code analysis tools to determine the validity of reported findings.

Teams that successfully completed all three tasks for a single challenge earned a bundle score, providing bonus points for a holistic solution. The challenges themselves were structured into two types:

  • Delta Scan: Competitors received a single diff file representing a Git commit, guaranteed to introduce a vulnerability. This allowed agents to focus their analysis on specific code changes.
  • Full Scan: The entire codebase was provided, requiring a broader analysis to uncover contextually vulnerable areas.

The competition targeted 28 diverse open-source projects, mirroring real-world software dependencies. These included widely used libraries and applications such as SQLite, lib XML, curl, Wireshark, Nginx, and Jenkins. Each challenge was packaged as a targz file, containing the source code and metadata, most notably a project.yaml file. This YAML file specified the target language (Java, C, or C++), the repository address, and a sanitizer key. Sanitizers, such as AddressSanitizer for C/C++, were crucial for scoring vulnerability proofs by triggering specific runtime errors. For Java, sanitizers were implemented per bug class (e.g., SSR, OS command injection), requiring more targeted trigger conditions. To ensure compilation and reproducibility, each challenge was provided within a Docker image, guaranteeing a consistent environment for building and testing instrumented binaries.

The competition statistics highlighted the scale and impact of the AIxCC. Out of 70 deliberately introduced vulnerabilities (a mix of synthetic bugs and real-world CVEs), participating teams collectively uncovered 54 (77%) and patched 43. Remarkably, 18 real-world zero-day vulnerabilities were discovered during the competition. The average time to patch a vulnerability, assuming a valid proof of vulnerability was found, was approximately 45 minutes. Furthermore, the end-to-end cost for uncovering and patching each bug, combining compute and human costs, averaged a strikingly low $152. These figures underscore the unprecedented efficiency achieved by AI-powered systems like ATLANTIS, dramatically outperforming traditional, human-centric bug bounty programs or hourly contractor models in terms of cost and speed.

Key Findings

▶ Watch: ATLANTIS architecture: diversity and complementary specialization (10:00)

Team Atlanta's ATLANTIS system demonstrated a profound advancement in AI's capability for automated security, leading to several key findings:

  1. Dominance in Comprehensive AI Security: ATLANTIS not only won the AIxCC but also dominated across all categories: vulnerability discovery, program repair, and SARIF assessment. This comprehensive victory validated its holistic approach to security automation.
  2. Discovery of Real-World Zero-Days at Scale: The system successfully identified 18 zero-day vulnerabilities during the competition. This remarkable feat, especially within complex open-source projects, proves AI's ability to uncover novel and critical flaws that might otherwise go unnoticed.
  3. Unprecedented Efficiency and Cost Reduction: The average cost of $152 per bug and an average time of 45 minutes for end-to-end analysis and patching represent a revolutionary improvement over traditional methods. This finding highlights the potential for AI to dramatically scale security efforts while reducing financial and temporal overheads.
  4. Effectiveness of Diverse, Complementary Strategies: A core design principle of ATLANTIS was "diversity and complementary specialization" among its bug-finding modules. This approach, where different modules employ varied techniques and specialize in different vulnerability classes or languages (e.g., C vs. Java), proved robust and effective, with each module contributing unique bug discoveries.
  5. LLM-Driven Fuzzing as a Game Changer: The integration of Large Language Models (LLMs) into fuzzing, particularly in the Uni (Universal AFL) and MLA (Multi-Language Agent) components, proved critical. By having LLMs generate scripts that produce inputs (rather than direct input bytes), ATLANTIS circumvented common LLM limitations (e.g., error-prone direct generation, safety guardrails) and achieved greater precision and adaptability across multiple languages.
  6. Iterative Refinement for Enhanced Payload Generation: The system's ability to iteratively refine LLM-generated input scripts based on source-level coverage feedback was a significant breakthrough. This feedback loop allowed the LLM to learn and adjust its strategies, leading to more targeted and effective payloads, even for complex vulnerability triggers.
  7. Impact of Domain-Specific Prompt Engineering: Tailoring prompts with specific domain knowledge, such as sanitizer-specific trigger strings (e.g., the Jaz string for Java command injection), drastically improved the accuracy of LLM-generated inputs by over 50%. This emphasizes the critical role of expert-informed prompt engineering in maximizing AI performance for security tasks.
  8. Variability and Evolution of LLM Performance: The talk revealed that LLM performance varies significantly not only across different models (e.g., Code Llama, Gemini, OpenAI) and their families but also with their age and training. Newer models are not always superior, and each may require specific prompt engineering for optimal results. Code Llama 70B ultimately proved to be the most efficient and accurate for ATLANTIS's overall bug-finding tasks.
  9. AI's Capability for Complex Payload Construction: The discovery of a use-after-free zero-day in SQLite, triggered by an "extremely complicated" SQL query that traditional fuzzers would likely miss, demonstrated AI's advanced reasoning capabilities in crafting intricate, multi-step attack vectors.

Technical Deep Dive

▶ Watch: Sanitizer-specific domain knowledge in prompts improved accuracy (21:40)

ATLANTIS is built upon a robust, scalable architecture deployed as a Kubernetes cluster on the Azure cloud. This Cyber Reasoning System (CRS) leverages two primary types of nodes: a persistent Per-CRS node and ephemeral Per-CP nodes. The Per-CRS node remains active throughout the competition, acting as a central orchestrator responsible for dispatching tasks and provisioning Per-CP nodes for each new challenge. Per-CP nodes, conversely, are instantiated only for the duration of a single challenge project's analysis, hosting the core bug-finding, patching, and SARIF assessment modules. To streamline internal management of budget and bookkeeping, ATLANTIS employs Redis within the Per-CRS node.

The talk primarily focused on the bug-binding modules, emphasizing a key design philosophy: diversity and complementary specialization. This principle ensured that each module adopted a distinct approach, allowing ATLANTIS to uncover a wider variety of bugs and maintain robustness against diverse inputs. For instance, separate modules were tailored for C, C++, and Java, each leveraging language-specific insights. The efficacy of this approach was evident in the competition results, where individual modules consistently discovered unique sets of vulnerabilities.

A central component of the bug-binding strategy is Uni (Universal AFL), a system designed for multi-language bug hunting. Uni itself incorporates diversity, particularly in its input generation mechanisms. While some components, like a given fuzzer or a concolic executor, operate without LLMs, ATLANTIS's strength lies in its MLA (Multi-Language Agent), an ensemble of five distinct agents that intensively utilize LLMs for their policies. Other modules, such as dictionary-based and grammar-based mutators, use LLMs moderately.

The MLA's bug-finding process is a sophisticated two-step approach:

  1. Hypothesize (Bug Inducing Things - BITs): This phase involves interprocedural analysis to synthesize potential bug hypotheses, termed BITs. A BIT encapsulates key conditions and a precise bug location. To trigger a vulnerability, specific conditions must be met: navigating to the vulnerable function, satisfying constraints leading to a vulnerable sink, and providing malicious input to that sink. For instance, in an OS command injection vulnerability in Apache Commons Compress, a BIT would identify the ProcessBuilder constructor as the sink and fileName as the malicious input, requiring navigation to the constructor and manipulation of fileName. A key insight here is to focus analysis only on "important functions"—those reachable from the fuzzer harness and, for delta scan challenges, those included in the provided diff file.
  1. Synthesize Concrete Inputs: This is the more innovative and complex phase. Instead of directly generating raw input bytes, ATLANTIS instructs LLMs to create scripts that, in turn, generate the seeds for fuzzing. This programmatic approach offers several advantages:
  • Reduced Error-Proneness: Scripts are less susceptible to "dump errors" like incorrect offsets or lengths often seen in direct LLM output.
  • Improved Debuggability and Transparency: Reviewing the generated scripts provides insight into the LLM's understanding of the target program, crucial for iterative improvement.

ATLANTIS employs three distinct strategies for concrete input synthesis:

  1. Single Highly Targeted Payload: The most rudimentary approach, where a Python script is generated to synthesize a specific malicious input, such as a gzip table with a filename like jzzd to trigger a command injection. This strategy aims for a "one-shot" intricate path to the bug.
  2. Multiple Targeted Payloads with Breadth: This strategy involves constructing a generator function that creates probabilistic payloads based on program analysis. An example shown was a script generating random XML with various entity files, aiming to reach different handlers within a parse_root function, thus broadening the fuzzing scope.
  3. Mutation Strategies for Depth: For deeper, already valid input structures, ATLANTIS generates mutation searchers. An example was an exit file mutator designed to corrupt various fields of an already valid exit file, allowing the fuzzer to explore deeper paths within complex data structures.

Crucially, the generation of these input scripts undergoes iterative refinement based on source-level coverage feedback. After running the LLM-generated scripts, the system provides the LLM with coverage logs. The LLM then "reflects" on its own output, identifying areas where coverage was insufficient (e.g., reaching a vulnerable function but not providing enough length for a buffer overflow) and adjusting the script accordingly. This feedback loop is repeated until a fixed number of iterations or until the script produces a crash.

Prompt engineering was also a critical factor in ATLANTIS's success. Standard best practices were followed, including clearly defining the LLM's role, workflow, context information, and providing output examples in the system prompt. For source code ingestion, techniques from literature like Rust Assistant and Anthropic Solides were employed. A particularly impactful strategy was the inclusion of sanitizer-specific domain knowledge in the prompts, especially for Java. For instance, explicitly informing the LLM about special string literals (like the Jaz string) required to trigger Java sanitizers improved the accuracy of generators and mutators by over 50%, demonstrating the power of domain expertise in guiding LLMs.

In terms of LLM selection, ATLANTIS observed varying performance across different models (e.g., Code Llama, Gemini, OpenAI models) and even within the same model family. Some models excelled in specific bug categories (e.g., SSRF), while others struggled. Interestingly, newer models sometimes lacked knowledge found in older ones, as seen in file path traversal examples where Code Llama, released later, performed worse than Gemini. Ultimately, Code Llama 70B was chosen for its overall efficiency and accuracy, despite minor limitations.

Demo / Proof of Concept

▶ Watch: Example of a complex SQLite use-after-free zero-day (24:00)

While the presentation did not include a live demonstration of ATLANTIS in action, Woosun Song provided a detailed proof-of-concept for one of the four zero-day vulnerabilities discovered by Team Atlanta during the semi-final and final rounds. This particular zero-day was a classical use-after-free vulnerability found in SQLite, a widely used embedded database engine.

The vulnerability was rooted in a specific callback mechanism that failed to re-initialize a data pointer to null under certain conditions. The scenario described involved creating a table indexed by the LSM1 module, which operates as a virtual cursor table. If two entries were created—one with key zero and a value of length six, and another with key one with a value of length seven—the ZData field would be reallocated during the second iteration, leading to a double free.

The fix for this vulnerability was remarkably simple: merely moving the initialization of the data pointer outside of its loop. However, the speaker emphasized that the payload required to trigger this bug was extremely complicated. It involved a highly intricate SQL query that would be exceptionally difficult for existing, traditional fuzzers to generate. This complexity, combined with the simplicity of the root cause, served as a powerful testament to ATLANTIS's advanced capabilities. It demonstrated how AI, particularly through its LLM-driven input generation and iterative refinement, could craft sophisticated, multi-step attack vectors that are beyond the reach of conventional bug-finding tools, thus representing a genuine advancement in AI-driven vulnerability discovery.

Defensive Implications

▶ Watch: Q&A: LLMs generate fuzzing scripts to bypass PoC rejection (28:10)

The success of ATLANTIS in the AIxCC carries profound implications for defensive cybersecurity strategies, signaling a transformative shift in how organizations can approach software security.

Firstly, ATLANTIS demonstrates that AI can significantly scale and accelerate vulnerability discovery and patching efforts. The reported average cost of $152 per bug and an end-to-end analysis and patching time of 45 minutes are game-changing metrics. This efficiency means that organizations can potentially analyze vast codebases more frequently and thoroughly than ever before, dramatically reducing their attack surface. Proactive patching, driven by AI's ability to not only find bugs but also generate code fixes, could become a standard practice, moving security from a reactive to a highly proactive stance.

Secondly, the advent of sophisticated AI systems like ATLANTIS necessitates a re-evaluation of traditional security resource allocation. If AI can automate large portions of vulnerability research and remediation, human security teams can shift their focus to higher-level strategic tasks, complex threat intelligence, and overseeing the AI systems themselves. This could lead to a more efficient use of scarce human expertise in cybersecurity.

However, the speaker also highlighted that AI is a "double-edged sword." While beneficial for defenders, it inherently boosts attacker productivity as well. The same efficiencies that allow defenders to find and patch bugs more cheaply and quickly also enable malicious actors to discover and exploit vulnerabilities at scale with unprecedented ease and low cost. This implies a new arms race in cybersecurity, where both sides leverage AI. Defenders must therefore rapidly adopt and integrate AI-powered security tools into their infrastructure to keep pace with, or ideally stay ahead of, AI-powered adversaries.

Furthermore, the speaker's personal next steps—focusing on the Web3 ecosystem—underscore the importance of applying AI security to rapidly evolving and often under-secured domains. The unique challenges and rapid growth of Web3, blockchain, and decentralized applications present fertile ground for AI to provide critical defensive value, addressing security gaps that traditional methods might struggle to cover effectively. Organizations operating in these emerging tech spaces should prioritize the integration of AI for continuous code review, smart contract auditing, and vulnerability assessment.

In essence, ATLANTIS paints a future where continuous, automated security analysis is not just aspirational but achievable. Defenders should look to integrate AI-driven fuzzing, static analysis validation, and automated program repair into their CI/CD pipelines to build security-in-depth and ensure rapid response to newly discovered threats. The era of AI-powered defense is here, and organizations that fail to embrace it risk falling behind in an increasingly automated threat landscape.

Key Takeaways

  • AI Cyber Challenge Validated AI's Capability: The AIxCC definitively proved that AI-powered systems can autonomously perform vulnerability discovery, program repair, and SARIF assessment with high efficacy.
  • Unprecedented Efficiency: ATLANTIS achieved an average cost of $152 per bug and an average time of 45 minutes for end-to-end vulnerability analysis and patching, significantly outperforming traditional methods.
  • LLM-Driven Fuzzing via Script Generation: A key innovation is having LLMs generate scripts (Python, etc.) that produce concrete inputs for fuzzers, rather than direct input bytes. This approach enhances accuracy, debuggability, and bypasses common LLM limitations.
  • Iterative Refinement with Coverage Feedback: The system's ability to iteratively improve LLM-generated input scripts based on source-level code coverage is crucial for crafting highly targeted and complex payloads.
  • Prompt Engineering is Paramount: Effective prompt engineering, including the integration of domain-specific knowledge (e.g., sanitizer-specific trigger strings), dramatically boosts LLM performance and accuracy in security tasks.
  • AI as a Double-Edged Sword: While AI significantly empowers defenders by scaling security efforts, it also enhances attacker capabilities, necessitating rapid AI adoption by organizations to maintain a defensive advantage.

About the Speaker(s)

Woosun Song is a PhD Student at Georgia Tech and was a key member of Team Atlanta, the winning team of the prestigious DARPA AI Cyber Challenge (AIxCC). Team Atlanta is a collaboration of institutions including Georgia Tech, KAIST and Samsung Research, comprising approximately 40 to 50 members who dedicated two years to developing the ATLANTIS system. Woosun's work on ATLANTIS, particularly in the multi-language agent and LLM-driven fuzzing components, was instrumental in the team's success. Following the AIxCC, Woosun Song is now embarking on a new project focused on creating an ATLANTIS-adjacent system specifically targeting the Web3 ecosystem, driven by the belief in the critical need for improved security in this rapidly growing space and the unique technical challenges it presents. He is part of a four-person team with advisory from Professor Kesun Kim and possesses a robust network and track record in AI and security.

Reviews

Dr. Zero (Offensive Security Researcher) — SOLID

Solid competition retrospective from the AIxCC winners with genuine technical meat on LLM-driven fuzzing architecture. The script-generation-instead-of-raw-bytes insight is the real contribution here. Loses a star because competition constraints shaped the system more than real-world deployment would, and some claims (the $152/bug figure) need caveats that didn't get airtime.

Heather Calloway (CISO) — STRONG ACCEPT

This is the first credible demonstration that AI can perform end-to-end vulnerability discovery and patch generation at scale, with real cost and time metrics. Every CISO with software in their supply chain needs to understand what this means for both defensive automation and attacker capability curves.

→ Top-rated talks at POC2025 (Power of Community)

All talks from POC2025 (Power of Community)