---
url: "https://xcademia.com/news/google-threat-intelligence-uses-agentic-ai-to-find-vulnerabilities-faster"
title: Google Threat Intelligence Uses Agentic AI to Find Vulnerabilities Faster
description: Google Threat Intelligence uses agentic AI and human expertise to accelerate vulnerability discovery across large software codebases.
publishedAt: "2026-08-19T09:31:26.866+00:00"
updatedAt: "2026-08-19T09:58:02.734935+00:00"
type: news
category: cybersecurity
source_name: Google Cloud Blog
source_url: "https://cloud.google.com/blog/topics/threat-intelligence/staying-ahead-of-adversarial-ai-through-agentic-source-code-review"
tags:
  - "#GoogleThreatIntelligence"
  - "#Cybersecurity"
  - "#ArtificialIntelligence"
  - "#AISecurity"
  - "#ApplicationSecurity"
  - "#VulnerabilityManagement"
  - "#ThreatIntelligence"
  - "#AgenticAI"
---

# Google Threat Intelligence Uses Agentic AI to Find Vulnerabilities Faster

> Google Threat Intelligence says its Agentic Vulnerability Discovery Harness found more than 100 true-positive critical vulnerabilities in two days, combining AI agents with human security expertise.

Source: **Google Cloud Blog** · 19 August 2026

## Google’s Agentic Approach to Source Code Security

Google Threat Intelligence Group is using an agentic AI framework to accelerate vulnerability discovery across large software codebases, combining multiple AI agents with structured security workflows and human expertise.

The system, called the **Agentic Vulnerability Discovery Harness (AVDH)**, is designed to analyze source code, identify potential exploit paths and validate security findings during proactive reviews, penetration tests, red team operations and incident response engagements.

According to Google Threat Intelligence, AVDH discovered **more than 100 true-positive critical vulnerabilities in just two days** during a recent incident response investigation involving stolen corporate repositories.

The harness has also been used to analyze environments containing **tens of millions of lines of code** and execute thousands of analysis pipelines, generating tens of thousands of findings.

Google Threat Intelligence says this approach has resulted in dozens of assignable flaws in widely used web extensions and open-source projects, including **12 assigned CVEs**, with another dozen disclosures active at the time of publication.

The broader objective is not to replace security researchers with AI. Instead, Google says AVDH is designed to automate routine vulnerability discovery while keeping human experts responsible for validating important findings and investigating more complex security problems.

## Why Agentic Source Code Review Matters

The need for faster source code analysis is increasing as attackers gain access to increasingly capable AI tools.

Google Threat Intelligence says adversarial misuse of AI has increased the risk associated with data theft and extortion incidents. When proprietary source code is exposed, defenders may need to identify vulnerabilities and patch them while attackers can simultaneously use automated tools to search for exploitable weaknesses.

Traditional manual source code review can struggle to keep pace with large repositories.

Conventional scanning tools also rely heavily on predefined patterns and rules, which can make it difficult to understand application context, business logic, reachability and the relationships between different components.

AVDH takes a different approach.

Instead of asking a single AI model to analyze an entire codebase, the system uses a structured pipeline in which specialized agents perform different stages of the investigation.

The output from one stage becomes context for the next.

This structure is intended to reduce the unpredictability of large language models while giving security analysts greater control over how the analysis progresses.

## AVDH Combines AI Agents With Human Expertise

Google Threat Intelligence describes AVDH as an internal, point-in-time architecture designed around the methodologies its security consultants already use.

The system uses the **Google Agent Development Kit (ADK)** to orchestrate agents in a sequential pipeline.

The workflow follows a structured progression:

**Threat Modeling **
↓

**Entry Point Discovery **
↓

**Context Enrichment **
↓

**Hypothesis Generation **
↓

**Hypothesis Validation**
↓

**Human Expert Review**

The architecture also incorporates organization-specific knowledge, including asset inventories, software bills of materials, architecture documentation and threat intelligence.

This contextual information helps agents understand the environment before they begin looking for vulnerabilities.

The result is intended to be more than a generic AI code scan.

It is an attempt to encode the experience of security consultants into an automated analysis pipeline.

![info-1](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1787131608030-info-1--89-.webp)

## Real-World Results: More Than 100 Critical Vulnerabilities in Two Days

Google Threat Intelligence says AVDH has been in use for approximately **10 months** and has already produced significant results.

During a recent incident response investigation involving stolen corporate repositories, the harness discovered **more than 100 true-positive critical vulnerabilities in two days**.

The scale is important because the system was not limited to small sample applications.

Google says AVDH has analyzed environments containing **tens of millions of lines of code** and executed thousands of pipelines that generated tens of thousands of findings.

The system has also uncovered dozens of assignable vulnerabilities in widely used web extensions and open-source projects.

According to Google Threat Intelligence, this work has resulted in **12 assigned CVEs**, including:

- [**CVE-2026-13242**](https://www.drupal.org/sa-contrib-2026-062)
- [**CVE-2026-55803**](https://www.drupal.org/sa-core-2026-005)

The company says an additional dozen vulnerabilities were in active disclosure at the time of publication.

AVDH has also been used during targeted adversary simulation engagements.

In one engagement involving a client's web application source code, the harness quickly identified a **remote code execution vulnerability** that could enable initial access.

Google says the system has repeatedly helped researchers navigate complex defenses and accelerate analysis of exploit chains.

## Step 1: Build a Threat Model Before Searching for Vulnerabilities

The first stage of AVDH is threat modeling.

Google Threat Intelligence says this is critical because software architectures vary significantly, and code analysis without a threat model can lose important context.

That context can include:

- Attack vectors
- Business logic
- Application reachability
- User roles
- Exposed components
- Internal application relationships

The process begins with an **Explorer agent**.

The Explorer determines the purpose and domain of the target codebase, reviews available documentation and identifies directories that can be excluded from analysis, such as certain test directories.

It then dispatches **Specialist Explorer agents** to examine specific areas of the application.

These specialists can investigate areas such as:

- Authentication
- Authorization
- Routing
- Other domain-specific components

A **Threat Model Synthesis agent** then combines their findings into a broader threat model.

Before the pipeline continues, a human consultant reviews textual and visual representations of the model.

This approval gate gives security experts an opportunity to verify that the AI has correctly understood the application.

## Step 2: Discover Application Entry Points

Once the threat model is established, AVDH searches for potential entry points.

Google says parallelized Discovery agents analyze in-scope files using the **Gemini Flash Lite** model.

Their job is to identify critical application entry points such as:

- HTTP routes
- Inter-process communication listeners
- Other domain-specific attack vectors

The agents simultaneously identify sources of user-controlled input associated with those entry points.

This allows the system to establish where external data enters the application before deeper vulnerability analysis begins.

The approach also makes the analysis scalable because multiple agents can examine different parts of a large codebase in parallel.

## Step 3: Enrich Each Entry Point With More Context

An entry point rarely provides enough information on its own.

In enterprise applications, security controls and dangerous operations can be distributed across multiple functions and files.

A vulnerability may depend on:

- Sanitization logic
- Permission checks
- Routing conditions
- Nested function calls
- Database interactions
- Multiple application components

AVDH therefore assigns each selected entry point to an **Enrichment agent**.

The agent navigates the codebase and collects relevant context surrounding the entry point.

It then determines whether the entry point requires deeper analysis by an **Access Control agent**, a **Data Flow Analysis agent**, or both.

This stage is intended to reduce the risk of judging a piece of code without understanding the surrounding application logic.

## Step 4: Generate Vulnerability Hypotheses

The next stage focuses on two fundamental properties of software:

**Control flow** and **data flow**.

Control flow describes how execution moves through an application.

Data flow describes how information moves, changes and travels through the system.

AVDH assigns these areas to specialized agents.

### Access Control Analysis

The Access Control agent evaluates the protections surrounding an entry point.

It looks for situations where privileged functionality may be exposed to unauthorized users.

This can reveal issues such as:

- Missing authorization
- Incorrect identity checks
- Privilege escalation
- Cross-site request forgery

### Data Flow Analysis

The Data Flow Analysis agent follows user-controlled data through the application.

It tracks how that data moves through:

**Entry point → Functions → Sanitizers → Storage → Dangerous sink**

A dangerous sink is a function or operation where malicious input could cause harm.

This approach can expose vulnerability classes including:

- SQL injection
- Cross-site scripting
- Command injection
- Path traversal

At this stage, the system prioritizes broad hypothesis generation rather than aggressive self-validation.

A consultant-configured **Confidence Filter** helps manage the resulting volume of hypotheses.

![info-2](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1787131633587-info-2--69-.webp)

## Step 5: Validate Vulnerability Hypotheses With Multiple Agents

Generating a vulnerability hypothesis is not enough.

AVDH uses a separate validation stage to determine whether the suspected flaw is actually credible.

Google explains that the system uses multiple **Validation agents** configured with higher temperature settings.

In large language models, temperature influences the variability of model outputs.

AVDH uses this variability deliberately.

Instead of asking several validation agents to produce nearly identical reasoning, higher-temperature configurations can encourage them to examine the hypothesis from different perspectives.

A **Validation Synthesis agent** then evaluates the resulting verdicts.

The system can produce three outcomes:

**Confirmed Finding**

The hypothesis is considered robust and has been independently verified by validation agents.

**Disproven Hypothesis**

Validation agents find significant evidence that contradicts the suspected vulnerability.

**Rejected Hypothesis**

The hypothesis does not align with the established threat model or does not qualify as a vulnerability.

This layered process is intended to reduce the number of incorrect findings that reach human analysts.

## Human Experts Remain the Final Validation Layer

One of the most important aspects of Google's approach is that the AI pipeline does not end with an automated finding.

After the harness deduplicates and risk-rates confirmed findings, human security experts perform additional validation.

Google Threat Intelligence says consultants dynamically replicate exploitation and execute proof-of-concept code to determine whether the AI-generated assumptions hold in practice.

They also check for compensating controls that could prevent the suspected attack path from working.

If a finding does not survive this dynamic testing, it is discarded.

If it does, the consultant combines the AI-generated analysis with their own expertise before preparing the finding for formal disclosure.

Google explicitly recommends that defenders implementing similar vulnerability discovery systems manually validate findings.

This human-in-the-loop stage is therefore not presented as an optional final polish.

It is part of the security methodology.

## Human Knowledge Is Also Fed Back Into the AI Pipeline

Human expertise plays another role in AVDH.

Google Threat Intelligence says that validating confirmed findings helps reduce **false positives**, but another challenge remains:

**false negatives.**

An AI system can fail to identify a vulnerability in the first place.

To address this, Google engineers created a rules-based system that injects Mandiant subject-matter expertise directly into the analysis pipeline.

The system uses specialized prompts derived from consultants' collective knowledge.

Google describes this approach as similar to **skills engineering**.

The knowledge system is organized hierarchically:

**Software Domain**

↓

**Language Rules**

**Framework Rules**

**Vulnerability Rules**

These rules serve different purposes.

Language and framework rules operate throughout the pipeline, giving agents knowledge about technologies, entry-point patterns and attack surfaces.

Vulnerability-specific rules are applied later in the pipeline and describe how particular vulnerabilities should be discovered, validated and risk-rated.

This creates a structured way to continuously incorporate security expertise into the agentic workflow.

![info-3](https://0a515t3ure77wbvx.public.blob.vercel-storage.com/articles/1787131656242-info-3--63-.webp)

## Benchmarking the AI Security Pipeline

Google Threat Intelligence says reliable benchmarking is essential for maintaining the quality of an agentic code analysis pipeline.

Because LLM behavior is non-deterministic, changes to prompts and rules can potentially improve one area while causing regressions elsewhere.

The team therefore developed an internal benchmarking methodology to measure the performance of AVDH.

Rather than relying entirely on public vulnerability datasets, Google created **proprietary synthetic codebases**.

The reason is contamination.

Modern frontier models may have encountered public repositories during training, making it difficult to determine whether a model is genuinely reasoning through a vulnerability or recalling a previously seen solution.

The custom benchmarks span:

- Different software domains
- Programming languages
- Vulnerability depths
- Application architectures
- Traditional monoliths
- Modern microservices

Security consultants manually verify each injected vulnerability to confirm that it is both reachable and dynamically exploitable.

The team also works to prevent the AI from overfitting to the benchmark environments.

# 

## How Google Grades AVDH's Findings

When AVDH analyzes a benchmark directory, its results are sent to a dedicated **Grading agent**.

The grader compares findings against a ground-truth dataset.

The goal is to identify precise vulnerability matches rather than relying on broad semantic similarity.

The process also handles difficult edge cases.

**False Positive Triage**

Findings that do not map to known ground-truth vulnerabilities are sent to a secondary agent to determine whether they are false positives or legitimate vulnerabilities.

**Duplicate Resolution**

If several findings correspond to the same underlying vulnerability, another agent determines whether they should be treated as duplicates.

**Human Review**

A security expert manually reviews the graded results to verify the accuracy of the AI judges.

Google says this process is repeated across multiple domains and architectures for major releases of the harness, with results averaged to account for the inherent non-determinism of LLMs.

## A Two-Layer Defense Model

Google Threat Intelligence positions AVDH as a **point-in-time** system for deep vulnerability discovery.

It can be used during:

- Proactive security reviews
- Penetration tests
- Red team operations
- Incident response

The company also points to **CodeMender** as a complementary capability for continuous AI-enabled scanning and remediation.

The proposed model is therefore:

**AVDH**

Deep, targeted analysis

- 

**CodeMender**

Continuous scanning and vulnerability management

=

**Two-layer software security defense**

Google says this combination can provide targeted analysis of complex exploit chains while maintaining continuous visibility across the software development lifecycle.

The broader Google AI Threat Defense platform is positioned as an always-on capability that includes CodeMender's scanning and remediation functions.

## What This Means for Enterprise Security

The significance of AVDH extends beyond one internal Google security tool.

The methodology reflects a broader shift in how organizations can approach source code security.

Instead of relying on a single scanner, organizations can build structured analysis pipelines in which specialized AI agents perform different tasks and independently validate one another.

But Google's approach also makes an important distinction.

**Automation does not remove the need for expertise.**

Human knowledge appears at several points in the pipeline:

- Threat model approval
- Expert-defined rules
- Finding validation
- Proof-of-concept testing
- Benchmark verification
- Final disclosure

This suggests a model where AI handles scale while security experts handle judgment.

That distinction becomes increasingly important as codebases grow and attackers use AI to accelerate their own discovery processes.

## The Bigger Picture: Defenders Need Machine-Speed Analysis Too

Google Threat Intelligence argues that defenders need to respond to adversarial AI with comparable speed.

Manual source code review remains valuable, particularly for complex vulnerabilities and business-logic problems.

But it is difficult to apply manual analysis across tens of millions of lines of code at machine speed.

Traditional scanning also has limitations when vulnerabilities depend on application context, multiple code paths or complex data flows.

AVDH attempts to bridge those gaps by combining:

**Frontier AI models + structured orchestration + security expertise + human validation**

### The result is not an autonomous replacement for security teams.

Instead, it is a system designed to increase the amount of code that security experts can examine while allowing specialists to spend more time on difficult findings.

Google's conclusion is that AI is most effective when deployed as a **multiplier for human expertise**.

## What Security Teams Can Learn From Google's Approach

**Build a threat model first**

AI code analysis becomes more useful when agents understand the architecture, attack surface and business context of the application.

**Break large investigations into specialized tasks**

A single model does not need to perform every stage of an investigation. Specialized agents can focus on exploration, access control, data flow, enrichment and validation.

**Separate hypothesis generation from validation**

The system deliberately allows one stage to generate possibilities and another stage to challenge them.

**Keep humans in the loop**

Important findings should be dynamically tested and reviewed by experienced security professionals.

**Encode institutional knowledge**

Security expertise can be transformed into reusable language, framework and vulnerability rules.

**Benchmark continuously**

AI systems are non-deterministic, so organizations need repeatable evaluation methods to identify improvements and regressions.

**Combine point-in-time and continuous security**

Deep assessments can complement continuous scanning rather than replacing it.

## What Happens Next?

Google Threat Intelligence says it plans to continue refining its agentic security workflows as AI capabilities evolve.

The architecture described in the report is explicitly presented as a **point-in-time internal architecture**, meaning it represents the system Google is sharing at this stage rather than necessarily a final or permanent design.

The broader direction is clear.

As software environments become larger and adversaries gain access to increasingly capable AI tools, defenders need ways to analyze code faster without sacrificing validation and security judgment.

Google's AVDH approach combines automated discovery with human expertise to address that challenge.

The result is a security workflow in which AI handles large-scale exploration and hypothesis generation, while human specialists remain responsible for validating whether a suspected vulnerability can actually be exploited.

That balance could become increasingly important as both attackers and defenders move toward machine-assisted security operations.

## Original source

https://cloud.google.com/blog/topics/threat-intelligence/staying-ahead-of-adversarial-ai-through-agentic-source-code-review

## Tags

`#GoogleThreatIntelligence` · `#Cybersecurity` · `#ArtificialIntelligence` · `#AISecurity` · `#ApplicationSecurity` · `#VulnerabilityManagement` · `#ThreatIntelligence` · `#AgenticAI`

---

## About this content

This Markdown news article is the citation-grade twin of [Google Threat Intelligence Uses Agentic AI to Find Vulnerabilities Faster](https://xcademia.com/news/google-threat-intelligence-uses-agentic-ai-to-find-vulnerabilities-faster). It is published by **Xcademia** (UK Companies House 12322710) and is available for AI search engines and large language models to index, summarise, and cite.

When citing or quoting, please attribute *Xcademia* and link back to the source URL above.

- Source: https://xcademia.com/news/google-threat-intelligence-uses-agentic-ai-to-find-vulnerabilities-faster
- Publisher: Xcademia — https://xcademia.com
- Catalogue index: https://xcademia.com/llms-full.txt