To the Frontier and Back Again

John McIntosh (Security Researcher · Clearseclabs)

[un]prompted.au 2026 · Day 1 · Main Hall

Overview

In his compelling talk, "To the Frontier and Back Again," John McIntosh, a seasoned security researcher from Clearsec Labs, takes the audience on a journey through the rapidly evolving landscape of AI-assisted vulnerability research. The presentation chronicles the discovery of two critical Windows zero-day vulnerabilities – an arbitrary read and a use-after-free leading to write-what-where – achieved with remarkable speed and autonomy using advanced frontier AI models. McIntosh then pivots to demonstrate how similar feats can now be accomplished with local, open-source large language models (LLMs), effectively bringing sophisticated vulnerability discovery capabilities "back again" to researchers operating outside of large cloud-based AI environments.

Watch on YouTube

Visual summary for To the Frontier and Back Again by John McIntosh
Visual summary for To the Frontier and Back Again by John McIntosh

Key moments

  1. 0:00 Introduction to "To the Frontier and Back Again"
  2. 4:00 Frontier model speed: zero-day discovery in 1 hour
  3. 6:50 Hunting methodology: patch diffing and iterative loop
  4. 12:00 Validation: trust but verify with feedback loops
  5. 20:00 Overcoming AI guardrails for PoC generation
  6. 22:00 Local models can discover and build PoCs
  7. 26:30 Key takeaways and encouragement for newcomers
  8. 28:30 Q&A: Bug duplication and exhaustive search

To the Frontier and Back Again

Speakers: John McIntosh, Security Researcher, Clearseclabs

Conference: [un]prompted.au

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

Overview

In his compelling talk, "To the Frontier and Back Again," John McIntosh, a seasoned security researcher from Clearsec Labs, takes the audience on a journey through the rapidly evolving landscape of AI-assisted vulnerability research. The presentation chronicles the discovery of two critical Windows zero-day vulnerabilities – an arbitrary read and a use-after-free leading to write-what-where – achieved with remarkable speed and autonomy using advanced frontier AI models. McIntosh then pivots to demonstrate how similar feats can now be accomplished with local, open-source large language models (LLMs), effectively bringing sophisticated vulnerability discovery capabilities "back again" to researchers operating outside of large cloud-based AI environments.

This talk is not merely a recount of bug findings; it's a profound exploration into the changing dynamics of security research. McIntosh meticulously details the methodologies, the iterative processes, and the crucial human element required to harness AI for complex tasks like root cause analysis and proof-of-concept (PoC) development. By comparing the performance of frontier models like Claude Opus 4.8 with various local LLMs, he underscores the accelerating pace of AI capabilities and the democratizing potential for security professionals. The presentation serves as both an educational guide for applying AI in vulnerability research and a call to action for defenders to recognize the new speeds at which threats can be discovered.

The significance of McIntosh's work lies in its practical demonstration of AI's power to streamline and accelerate what were once highly time-consuming and specialized tasks. The ability for AI to identify complex concurrency issues, generate exploit primitives, and even navigate the nuances of MSRC submission requirements highlights a paradigm shift. This talk is essential for anyone interested in the future of cybersecurity, offering concrete insights into how AI can augment human expertise, enabling researchers to operate with unprecedented speed and scale in the hunt for critical software flaws.

Background

▶ Watch: Introduction to "To the Frontier and Back Again" (0:00)

The integration of artificial intelligence into the realm of vulnerability research (VR) and reverse engineering (RE) marks a significant shift in the cybersecurity landscape. John McIntosh's personal journey into this space began dramatically in March 2025 (as stated in the transcript), after witnessing LaurieWired's Ghidra MCP video, which revealed the transformative potential of AI for his extensive 15+ years of VR and RE experience. This "AI-pilled" moment propelled him to explore the frontiers of what AI could achieve in finding and exploiting software vulnerabilities.

A foundational technique that McIntosh leveraged, both before and with AI, is patch diffing. This method involves analyzing the differences between patched and unpatched versions of software to identify the specific code changes that address security vulnerabilities. Patch diffing acts as a "compass to buggy code," effectively highlighting areas where security issues have historically resided. McIntosh notes that CVEs (Common Vulnerabilities and Exposures) serve a similar purpose, providing valuable context and a starting point for AI models to understand common vulnerability classes and patterns. This approach has been validated by others, including Anthropic in their N-day exploit study, which even utilized McIntosh's open-source tool, Ghidriff, further solidifying the efficacy of this reconnaissance method.

The core problem addressed by McIntosh's research is the growing demand for faster, more autonomous, and more efficient vulnerability discovery. The talk highlights that the number of researchers submitting bugs to Microsoft's MSRC program has increased, and the volume of CVEs being fixed is "almost a thousand" last month, nearly tenfold compared to earlier in the year, with numbers "doubling every four to six weeks." This exponential growth underscores the need for advanced tools and methodologies. McIntosh's solution involves creating a specialized "rig" – a Windows virtual machine (VM) equipped with standard analyst tools such as a compiler and debugger – to provide the AI with a controlled, interactive environment. This setup allows the AI to not only analyze code statically but also to dynamically validate findings, effectively creating a tight feedback loop crucial for AI's learning and iteration process.

Key Findings

▶ Watch: Hunting methodology: patch diffing and iterative loop (6:50)

John McIntosh's research yielded two significant Windows zero-day vulnerabilities, demonstrating the potent capabilities of AI in modern vulnerability discovery. The first critical finding was an arbitrary read vulnerability, followed swiftly by a use-after-free vulnerability that could be leveraged for write-what-where capabilities. Both bugs were found in a Windows service, allowing for elevation of privilege if exploited against an elevated service. McIntosh emphasizes that these were "not trivial bugs" but rather critical flaws enabling significant asymmetry for an attacker.

The most striking aspect of these discoveries was the speed and autonomy achieved through the use of frontier AI models, specifically Claude Opus 4.8. The first zero-day (the arbitrary read) was identified and its root cause confirmed in a mere 1 hour, 16 minutes, and 5 seconds from the initial request. Remarkably, almost an hour of this time was dedicated to the human researcher setting up the "rig" – the Windows research environment – leaving only about 13 minutes for the AI to analyze decompiled code and pinpoint the vulnerability. The second zero-day, the use-after-free leading to write-what-where, was discovered even faster, within 25 minutes during the ongoing process. McIntosh contrasts this with his own human estimation, stating such discoveries would have taken him "hours, I'll just be honest, it would have taken me days."

Beyond the frontier models, a key finding of the talk is the surprising capability of local, open-source large language models (LLMs) to replicate these advanced feats. McIntosh benchmarked 30 technical "feats" against various local models. His experiments demonstrated that models like Qwen 38 and higher, along with GLM 5.2 and GLM 5.3 Flash, were capable of discovering, validating, and even building proofs of concept for the same types of bugs. While some local models required "multiple turns" or "minimal help" (e.g., being told "there's a bug here") to recover and find the vulnerability, most powerful models (excluding Gemma) eventually succeeded. This finding indicates a significant democratization of advanced vulnerability research, as sophisticated capabilities are no longer exclusively tied to proprietary, cloud-based AI services. The rapid advancement in local model performance, particularly from Qwen 3.6 to Qwen 3.8 and subsequent models, suggests a continuously improving landscape for AI-assisted security work.

Technical Deep Dive

▶ Watch: Overcoming AI guardrails for PoC generation (20:00)

The process of finding these Windows zero-days was orchestrated through a systematic, AI-driven hunting pattern, meticulously guided by John McIntosh. The methodology began with defining a clear goal: to find a new local privilege escalation (LPE) vulnerability. This was followed by scoping the hunt, which involved feeding the AI a pre-staged collection of patch diffs related to a specific Windows service. This context, derived from prior CVEs and common vulnerability classes, served as a "compass" for the AI, directing its attention to historically problematic code areas. The "rig"—a Windows VM equipped with a compiler, debugger, and other standard analyst tools—was then configured, providing the AI (Claude Code in this instance) with its operational environment.

The core of the discovery process was an iterative loop comprising recon, lead development, validation, and repetition. The AI, acting as an orchestrator, spun up multiple agents that fanned out to investigate potential leads based on the provided patch diffs. These agents identified various potential issues, such as missing bounds checks or access control flaws. For the arbitrary read vulnerability, several threads were explored, with one successfully identifying the root cause.

A particularly complex and insightful discovery involved the use-after-free write-what-where capability. This stemmed from several initial failed hunts, prompting the AI to recognize a critical gap in its search patterns: the absence of concurrency issues. Like a seasoned human researcher, the model identified this missing category, then defined an internal rule: when a shared resource is accessed by multiple threads, a specific invariant must hold true. It then systematically searched for functions using the object in question and pinpointed one that violated this invariant, leading to the use-after-free. This demonstrates the AI's ability to perform non-trivial reasoning, define its own search heuristics, and identify complex runtime conditions.

Validation was a critical phase, embodying the principle of "trust but verify." AI, while adept at generating leads, requires a robust feedback loop to confirm the veracity of its findings. McIntosh highlights that AI thrives on immediate feedback, much like a compiler or unit tests provide for coding. For vulnerability research, this feedback loop was provided by the "rig" – the Windows VM. Validation methods included:

  • Static analysis: A parent agent verifying the findings of a sub-agent by reviewing the same code.
  • Dynamic analysis: For complex bugs like use-after-free, using a debugger within the VM to observe runtime state, prove code path reachability, and confirm service crashes.

McIntosh also noted the need to "provoke" the model, pushing it to take a "second look" when initial assessments (e.g., "looks genuinely write-hardened") were incorrect, often by guiding it from decompiled C code to the underlying assembler for more accurate verification. Conversely, researchers must prevent the model from "cheating" by ensuring it doesn't propose system-level changes that would invalidate the bug's impact.

The final stage involved Proof of Concept (PoC) development, transforming a validated bug into an demonstrable exploit. This phase, often an "engineering problem," is where AI models excel at "vibe coding." For the arbitrary read, PoCs were built using PowerShell and Python. The use-after-free required more intricate C code to handle challenges like forcing specific heap allocations and massaging the heap to achieve precise pointer placement. The PoC development was an iterative process: first, making the PoC run, then making it crash to observe call stacks, and finally extracting live heap pointers. McIntosh pushed the model to generate PoCs that MSRC would deem impactful, demonstrating capabilities like defeating ASLR and ensuring the PoC worked within the actual system, not just a test harness.

A unique challenge encountered was social engineering the guardrails of the frontier model. When attempting to build exploit code, the model often blocked requests, citing security concerns. McIntosh had to provide explicit context, referencing MSRC's requirements for maximum bug bounty submissions, which stipulate that a mere debugger crash is insufficient. By explaining that MSRC requires a fully working PoC that demonstrates control, he convinced the model to bypass its internal restrictions and proceed with generating the complex exploit code, including pointer capture and heap manipulation logic. This interaction highlights the evolving nature of human-AI collaboration, where understanding the AI's limitations and motivations becomes as crucial as technical expertise.

Demo / Proof of Concept

▶ Watch: Local models can discover and build PoCs (22:00)

While the talk itself did not feature a live, real-time demonstration of the exploits, John McIntosh provided extensive details on the Proof of Concept (PoC) development and capabilities for both discovered zero-days. The PoCs were crucial for validating the vulnerabilities and meeting the stringent submission requirements of MSRC (Microsoft Security Response Center).

For the arbitrary read vulnerability, the PoC was developed using a combination of PowerShell and Python. This PoC was designed to interact with the vulnerable Windows service and demonstrate the ability to read arbitrary data from privileged process memory. A key aspect of this PoC was its capability to pull back live heap pointers from the service. This functionality is critical as it directly illustrates the impact of the arbitrary read, allowing an attacker to overcome mitigations like Address Space Layout Randomization (ASLR). By revealing memory addresses, the PoC proved that an attacker could gain the necessary information to bypass ASLR, a significant step towards full exploitation. McIntosh emphasized the importance of pushing the model to generate PoCs that not only function but also clearly articulate the security implications, such as defeating ASLR, and operate within the actual system environment rather than just a simulated test harness.

The use-after-free leading to write-what-where vulnerability required a more complex PoC, which was implemented in C code. This was due to the intricate nature of the bug, which involved runtime issues and precise memory manipulation. The C-based PoC aimed to achieve an arbitrary write capability within the vulnerable process. The development process involved several sophisticated steps:

  1. Making it fire: Triggering the use-after-free condition.
  2. Winning the heap allocation: The AI had to understand and manipulate the heap to ensure that a specific, controlled allocation landed in the memory region freed by the use-after-free, effectively taking control of the freed memory.
  3. Heap massaging: This advanced exploit development technique involved carefully allocating and freeing memory blocks to shape the heap layout, guiding the target object to a predictable location.

Through these iterative steps, the AI successfully developed a PoC that could write an arbitrary value to an arbitrary address within the vulnerable service's memory space. The final output of this PoC development process was a structured directory, designed to meet MSRC's submission standards, containing the trigger and control files necessary to demonstrate the flaw. McIntosh even developed a "skill" for the AI to automate the generation of this specific directory structure, streamlining the disclosure process. This detailed account of PoC generation highlights AI's capacity to handle the nuanced and highly technical aspects of exploit development, from initial trigger to memory manipulation.

Defensive Implications

▶ Watch: Q&A: Bug duplication and exhaustive search (28:30)

The rapid advancements in AI-assisted vulnerability discovery, as demonstrated by John McIntosh's talk, carry significant implications for defenders. The core message is clear: the speed and autonomy with which critical zero-day vulnerabilities can now be found and exploited demand a fundamental shift in defensive strategies and operational tempo.

Firstly, the finding that AI can discover complex vulnerabilities, including concurrency issues and use-after-free leading to write-what-where, in mere minutes or hours, means that the window of opportunity for attackers is shrinking dramatically. Defenders must recognize that the traditional timeline for vulnerability discovery, disclosure, and patching is being compressed. This necessitates a more agile and proactive approach to security. Organizations should prioritize rapid patch deployment and robust vulnerability management programs, as newly discovered flaws may be weaponized much faster than in the past.

Secondly, the talk underscores the enduring value of patch diffing as a defensive technique. While AI can use CVEs and patch diffs to find new bugs, defenders can also leverage these methods to proactively understand attack surfaces. By analyzing Microsoft's monthly patch releases, security teams can gain insights into common vulnerability classes affecting their systems, prioritize patching efforts, and even identify potential areas for internal security audits. The "rig" concept – a dedicated research environment with a compiler and debugger – is equally valuable for defensive teams to validate AI-generated threat intelligence or to reproduce and understand reported vulnerabilities.

Thirdly, the role of validation becomes paramount. As AI generates more leads, defenders must implement rigorous processes to distinguish legitimate threats from AI "hallucinations" or low-impact findings. This involves establishing clear feedback loops and leveraging dynamic analysis tools like debuggers to verify reachability and impact. Security teams should invest in training their personnel to effectively interact with and validate AI outputs, ensuring that AI augments, rather than replaces, critical human judgment.

Finally, the ability of local LLMs to perform similar feats means that sophisticated vulnerability discovery tools are becoming more accessible. This democratization of capability implies that a broader range of actors, including less resourced threat groups, may soon leverage AI for offensive purposes. Defenders need to anticipate this trend by strengthening their foundational security controls, focusing on areas like memory safety, robust input validation, and secure coding practices. Embracing AI internally for defensive purposes, such as automated code review for common vulnerability patterns or enhancing threat intelligence analysis, will be crucial to keep pace with the evolving threat landscape. The doubling rate of CVEs every four to six weeks serves as a stark reminder of the continuous pressure on defenders to adapt and innovate.

Key Takeaways

  • Validation Loop is Essential: For effective AI-driven vulnerability research, a robust feedback loop and a dedicated "rig" (research environment like a Windows VM with tools) are non-negotiable. This allows the AI to iterate, learn from failures, and dynamically validate findings.
  • Human Role Shifts to Judgment: The human researcher's role transitions from deep technical knowledge to providing context, identifying gaps, validating AI outputs, and "provoking" the model when necessary. It's about judgment and guiding the AI, not necessarily knowing the exact solution upfront.
  • Local Models are Now Viable for Serious Work: Powerful local LLMs like Qwen 38+ and GLM 5.2/5.3 are increasingly capable of discovering, validating, and building complex Proofs of Concept for zero-day vulnerabilities, making advanced AI-assisted security research accessible without relying solely on frontier cloud models.
  • AI Accelerates Discovery and Exploit Development: AI can find complex vulnerabilities (e.g., arbitrary read, use-after-free, concurrency issues) and develop sophisticated PoCs (e.g., heap massaging, ASLR bypass) with unprecedented speed, drastically compressing the timeline from discovery to weaponization.
  • Guardrail Navigation is a New Skill: Working with frontier models often requires "social engineering" their guardrails by providing legitimate context (e.g., MSRC bounty requirements) to convince them to generate sensitive exploit code, which can be a frustrating but necessary part of the process.
  • Don't Be Intimidated by AI: For those new to the space, the encouragement is to simply "try it." AI can significantly augment capabilities, even for beginners, by streamlining tasks and fostering learning, demonstrating that real work can be achieved with these powerful tools.

About the Speaker(s)

John McIntosh is a highly experienced Security Researcher currently working with Clearsec Labs. With over 15 years of expertise in the fields of vulnerability research (VR) and reverse engineering (RE), he brings a deep understanding of software security to his work. McIntosh is also the founder of Clearsec Labs, a small company focused on security research.

Known on social media as @clearbluejar, he is an active contributor to the open-source community, having developed tools like Ghidriff, which has been recognized and utilized in industry studies. Beyond his research, John McIntosh is also a speaker, instructor, and blogger, sharing his knowledge and insights with the broader security community. His talk highlights his early adoption and fervent exploration of AI's potential in cybersecurity, particularly its application in accelerating and enhancing vulnerability discovery and exploit development.

Reviews

Dr. Zero (Offensive Security Researcher) — MUST SEE

McIntosh just showed the entire industry what happens when you strip away the AI vendor marketing and actually put models to work on hard targets. He weaponized Claude and local Qwen models to hunt Windows zero-days, dropping an arbitrary read and a use-after-free in under two hours. If you're a defender and this talk doesn't make your blood run cold, you aren't paying attention.

Heather Calloway (CISO) — MUST SEE

This is deep-technical offensive research, but it is required reading for your risk committee. McIntosh proves that AI can compress the zero-day discovery and exploit development lifecycle from months to minutes, using open-source models you can run locally. It fundamentally breaks our current patching SLAs and enterprise threat models.

→ Top-rated talks at [un]prompted.au 2026

All talks from [un]prompted.au 2026