The Agentic Frontier of Proactive Defense

Salim Chawro (Microsoft), Zeeshan Syed (Microsoft)

BlueHat Asia 2026 · Day 2 · Main Stage

Overview

In an era where cloud infrastructure scales to unprecedented levels and the window for responding to vulnerabilities shrinks to negative timeframes, traditional security assurance models are proving insufficient. This talk, "The Agentic Frontier of Proactive Defense," presented by Microsoft security engineers Salim Chawro and Zeeshan Syed at BlueHat Asia, addresses this critical challenge head-on. They introduce Argus, a groundbreaking frontier security assurance system that leverages AI agents and maximal context to deliver expert-grade, architecturally aware, and continuously operating security reviews at Microsoft's immense cloud scale.

Watch on YouTube

Visual summary for The Agentic Frontier of Proactive Defense by Salim Chawro, Zeeshan Syed
Visual summary for The Agentic Frontier of Proactive Defense by Salim Chawro, Zeeshan Syed

Key moments

  1. 0:00 The massive scale and pace of security challenges
  2. 7:30 Argus: Agentic execution and maximizing context
  3. 11:00 Agent framework: The body for AI models' brain
  4. 13:00 Argus's 6-stage proactive security assurance workflow
  5. 19:40 Root cause analysis: Fixing the disease, not symptoms
  6. 23:00 Automated remediation: Containment and durable architectural fixes
  7. 24:30 Results: High accuracy, nuanced findings, reviews in hours

The Agentic Frontier of Proactive Defense

Speakers: Salim Chawro (Microsoft); Zeeshan Syed (Microsoft)

Conference: BlueHat Asia

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

Overview

In an era where cloud infrastructure scales to unprecedented levels and the window for responding to vulnerabilities shrinks to negative timeframes, traditional security assurance models are proving insufficient. This talk, "The Agentic Frontier of Proactive Defense," presented by Microsoft security engineers Salim Chawro and Zeeshan Syed at BlueHat Asia, addresses this critical challenge head-on. They introduce Argus, a groundbreaking frontier security assurance system that leverages AI agents and maximal context to deliver expert-grade, architecturally aware, and continuously operating security reviews at Microsoft's immense cloud scale.

The core problem tackled by Chawro and Syed is the unsustainable pace of manual security assurance against a backdrop of exploding service growth and accelerating exploit timelines. Microsoft, with over 9,500 services comprising tens of millions of lines of code deployed across millions of nodes, faces an existential security challenge that cannot be solved by simply hiring more people. Argus represents a paradigm shift, moving from reactive vulnerability patching to proactive, architectural-level root cause analysis and automated remediation, fundamentally reshaping how large-scale cloud environments can be secured.

This article delves into the motivations behind Argus, its innovative technical architecture, the challenges it overcomes, and its profound implications for the future of defensive security. By understanding the system's design principles—such as agentic execution, context maximization, and hierarchical agent orchestration—security professionals can glean valuable insights into building resilient, AI-powered defenses capable of anticipating and mitigating threats before they materialize.

Background

▶ Watch: The massive scale and pace of security challenges (0:00)

The impetus for developing Argus stems from two converging, intractable problems facing hyper-scale cloud providers like Microsoft: scale and pace.

The scale problem is staggering. Microsoft operates over 9,500 commercial cloud services, each with tens of millions of lines of code deployed on millions of global nodes. Securing such a vast and complex fleet proactively, rather than reactively, is an immense undertaking. The traditional approach of "throwing people at the problem" is no longer viable, as the growth rate of services far outstrips any feasible hiring plan. A few years ago, the ecosystem was significantly smaller, but the current expansion rate is unprecedented.

Compounding the scale issue is the alarming acceleration of the pace problem. The mean time to exploit (MTTE), which measures the time between a vulnerability's public disclosure and its exploitation in the wild, has collapsed dramatically. In 2021, defenders had roughly a year of breathing room. Today, this number is "negative," meaning exploits are occurring before public disclosure. This collapse is largely attributed to AI assistance, where frontier models are proving highly effective at discovering vulnerabilities at scale and aiding in exploit development. The speakers cited a recent example where Microsoft shipped 974 CVEs, including 10 critical and 20 wormable vulnerabilities, with some already being exploited in the wild, underscoring the urgency of the problem.

Traditionally, Microsoft has invested decades in a discipline called security assurance. This proactive model focuses on deeply understanding each service's architecture, including its crown jewels, identity models, trust boundaries, and dependency chains. Based on this understanding, security controls are applied, evaluated, and a risk profile is established. The goal is to elevate a service's security maturity by addressing architectural categories of problems, avoiding a "whack-a-mole" approach to individual vulnerabilities.

However, even this robust security assurance model buckles under the weight of current demands. Applying this detailed process to 9,500 services creates immediate scaling bottlenecks. Gathering evidence for each service is time-consuming, and evaluating security controls requires highly specialized security experts, who are a scarce resource. This leads to prioritization challenges, where not all services can receive the necessary attention. Furthermore, security assurance reviews are inherently point-in-time snapshots. Modern development cycles, where a single developer can now deliver code in days that once took weeks or months for a team, mean that architectures, code, identity models, and dependencies evolve constantly. Running comprehensive reviews frequently enough to keep pace with this rapid evolution is simply not feasible with human-centric processes.

A common industry reflex to the AI revolution has been to apply frontier models directly to source code to find vulnerabilities quickly. While this yields more identified issues, it suffers from a critical flaw: code is not an isolated entity. Its security posture is inextricably linked to its context—its architecture, dependency chain, trust boundaries, and identity models. The same piece of code can be harmless in one service but critically exploitable in another. Therefore, simply finding code-level vulnerabilities without architectural context leads to chasing symptoms rather than addressing root causes. The problem statement crystallizes: a truly effective solution must be a security expert-grade, architecturally aware, full-context security assurance system that operates not only at cloud scale but also at the unprecedented pace dictated by modern AI capabilities.

Key Findings

▶ Watch: Agent framework: The body for AI models' brain (11:00)

The development of Argus is underpinned by two fundamental principles designed to overcome the limitations of traditional security assurance: agentic execution and maximizing context. These principles form the bedrock of a system capable of delivering proactive, architectural-level security at hyper-scale.

Firstly, agentic execution involves using AI agents to implement a human-inspired security assurance workflow. Security assurance, by its nature, is a structured process: human experts understand a service, define assurance goals, review them, synthesize findings, and drive remediation. This systematic approach is ideal for automation. The evolving capabilities of AI agents—in planning, execution, memory management, and tooling—enable the construction of complex orchestration flows where specialized agents can collaborate on intricate problems. Crucially, even with automation, Argus maintains an express human gate for reviewing and approving final outputs, acknowledging that while agents excel at sifting vast data, final judgment and executive action still require human oversight.

Secondly, maximizing context is identified as a critical differentiator and a strategic advantage for defenders. While attackers often view services from the outside, defenders possess a complete inside-out view. The effectiveness of AI models depends critically on the quality and breadth of information provided. As AI models become increasingly commoditized, it is this rich, internal context—encompassing everything from source code to network topology—that truly empowers defenders to extract maximum value from AI and stand out. Argus prioritizes ingesting every conceivable piece of information to provide the AI agents with an unparalleled understanding of the service being analyzed.

Beyond these foundational principles, the Argus system has yielded several key findings in its application:

  • High Accuracy: The system achieves "very high levels of accuracy," with over 90% of findings confirmed as genuine security issues. This precision is a direct result of its deep contextual understanding, encompassing not just code but also runtime environment, identities, and topology.
  • Discovery of Nuanced, Cross-Domain Issues: Argus is proficient at identifying "interesting, nuanced, cross-domain issues" that traditional security tools often miss. This capability to uncover subtle, interconnected vulnerabilities is crucial for strengthening complex cloud services.
  • Rapid Assurance Reviews: A significant finding is the ability to complete proactive assurance reviews for services within hours. This dramatically increased speed allows for much more frequent and rigorous reviews across massive cloud portfolios, keeping pace with rapid development cycles.
  • Architecturally Driven Root Cause Analysis: Argus moves beyond individual "point findings" to identify thematic issues and root causes. By understanding the underlying architectural flaws, the system enables fixes that eliminate entire classes of problems, rather than merely addressing symptoms.
  • Automated Remediation Guidance: The system not only identifies issues but also generates practical remediation guidance. This includes both short-term containment strategies (e.g., tightening policies, disabling behaviors) and durable architectural fixes for long-term elimination of root causes, complete with validation criteria.

These findings collectively demonstrate that Argus represents a significant leap forward in proactive defense, offering a scalable, precise, and efficient mechanism for securing complex cloud environments against rapidly evolving threats.

Technical Deep Dive

▶ Watch: Argus's 6-stage proactive security assurance workflow (13:00)

The technical architecture of Argus is designed to overcome the inherent limitations of directly applying frontier AI models to complex security assurance tasks. While large language models (LLMs) are powerful, they face challenges such as limited context memory (even 1 million tokens is insufficient for cloud services orders of magnitude larger), an inability to methodically search large spaces, and a lack of intrinsic persistence. Argus addresses these by employing an agentic framework that acts as the "body" around the LLM "brain."

This framework performs several critical functions:

  • Task Decomposition: It takes a complex assurance task and breaks it down into smaller, manageable pieces.
  • Specialized Agent Distribution: These sub-tasks are then distributed across different specialized agents, each with scoped functions, allowing for parallel processing and expertise application.
  • Context Management: The framework ensures that the "right context" is delivered to the "right agent" at the "right time," optimizing the use of limited LLM context windows.
  • Coordination and Synthesis: It coordinates the work of multiple agents and synthesizes their individual findings back into a coherent assurance process.
  • Search Planning and Coverage Tracking: For assurance processes that inherently involve searching over large control surfaces, the framework handles search planning, decomposition, and systematically tracks coverage to ensure no critical areas are missed.
  • Persistence and Long-Term Coherence: For long-running assurance reviews, the framework provides supporting memory architectures, including tiers of memory (long-term, episodic, working), to maintain coherence and persistence across the entire process.

The Argus workflow, as described by the speakers, is a sophisticated six-stage process:

  1. Maximum Context & Rich Service Profile: This initial stage focuses on ingesting and synthesizing a vast array of information to build a comprehensive understanding of the service. This includes source code, configurations, resource properties, service identities, and network topology. The system then agentically constructs a rich service profile, detailing key components, data flows, architecture, trust boundaries, and invariants. This multi-artifact, consolidated view is foundational for all subsequent assurance activities.
  1. Tailored Control Tree: Argus then dynamically creates a service-specific, customized tree of controls. Starting with high-level security properties (e.g., authorization, authentication, tenant isolation), these properties are interpreted within the unique context of the service. They are then recursively decomposed into sub-controls and further into micro-controls, which are directly verifiable statements. This allows for precise, context-aware security goal definition.
  1. Control Verification: In this stage, the system verifies the micro-controls, much like a human expert would. It systematically evaluates the service against these granular control statements, rolling up learnings from the micro-level to the macro-level to assess overall compliance and identify deviations.
  1. Finding Aggregation: Beyond its core control-driven analysis, Argus integrates findings from other security tools and scanners, as well as pattern-driven findings. This provides a holistic view, combining the deep architectural insights of Argus with broader vulnerability detection capabilities.
  1. Multi-step Exploit Reasoning & Validation: This is a crucial stage where Argus moves beyond isolated findings. It reasons about how individual vulnerabilities or control weaknesses could be chained together to form multi-step exploits. The system validates potential exploit paths, determines their severity, and aligns them with established bug bars, providing a realistic assessment of potential impact.
  1. Remediation: The final stage focuses on actionable outcomes. With its deep understanding of the service architecture and identified issues, Argus generates precise remediation guidance. This includes both short-term containment measures (e.g., policy tightening, behavior disabling, enforcement mechanism additions) and durable architectural fixes designed to eliminate the root cause permanently. Importantly, the system also defines validation criteria to confirm the effectiveness and completeness of the proposed fixes.

The design principles guiding Argus's implementation are critical for its success in long-running, multi-artifact assurance processes across massive service contexts:

  • Hierarchy of Agents: The system employs a layered agent architecture, including an orchestration layer, an analysis layer, and an evidence layer. This division of labor into specialized agents with scoped functions and clear handoffs allows for the efficient coordination of complex tasks, making the whole greater than the sum of its parts.
  • Global Planning and Local Reactivity: Argus maintains a global plan for the overarching assurance process, providing long-term coherence and a shared "North Star" for all agents. Simultaneously, agents are designed to be reactive to every piece of incoming data, allowing for adaptive responses and dynamic adjustments during execution.
  • Tiers of Memory: To manage the enormous context and long-running nature of assurance reviews, Argus utilizes a sophisticated memory architecture with distinct tiers: long-term memory for foundational knowledge, episodic memory for past interactions and events, and working memory for immediate task-relevant information.
  • Diversity of Reasoning: The system leverages multiple AI models and reasoning frames. By reasoning multiple times across diverse perspectives and synthesizing the results, Argus can capture a richer, more robust understanding of the problem space and potential solutions.

The outputs of the Argus system are designed to be immediately actionable and provide profound insights:

  • A rigorous analysis of architecture, component topology, trust boundaries, and data flows, highlighting key components, connections, and, critically, the strength and weaknesses of trust boundaries. This often reveals discrepancies between service owners' perceived architecture and the actual implementation.
  • Identification of control family coverage, architectural risks, and root causes. Instead of isolated findings, Argus surfaces thematic issues, enabling fixes that eliminate entire classes of problems. For instance, the speakers presented a synthetic service example where findings R1 (tenant identity changing), R4 (wrong customer credentials), and R5 (overly broad operator access) were traced back to a single root cause: making decisions based on stored information rather than verified authority. Fixing this by establishing a trusted identity and verifying it before action eliminates all three problems.
  • Detailed threat models and impact analysis, tracing how weaknesses translate into tangible impacts like cross-tenant access or credential misuse, and pinpointing the specific components where trust assumptions are violated.
  • Comprehensive remediation guidance, encompassing both rapid, short-term containments and durable, long-term architectural fixes, complete with validation criteria to ensure effectiveness.

Demo / Proof of Concept

▶ Watch: Automated remediation: Containment and durable architectural fixes (23:00)

While the talk did not feature a live, interactive demonstration of the Argus system in action, the speakers provided a detailed walkthrough of its capabilities and outputs using a synthetic service example and illustrative diagrams. This allowed them to articulate how Argus processes information, identifies issues, and proposes solutions in a practical context.

A key aspect highlighted was the system's ability to perform architecturally driven root cause analysis. Using the synthetic service, the speakers described three seemingly disparate findings:

  • R1: Tenant identity changing
  • R4: Having the wrong customer's credentials
  • R5: Operators having broader access than intended

Argus, however, recognized that these were not independent issues. Instead, they were all grounded in a shared root cause: the system was making decisions based on information it stored rather than authority it verifies. The solution, identified by Argus, was to "create a trusted identity once and have every component verify that before taking action." By addressing this single architectural root cause, the system could prevent tenant identities from being changed, ensure credentials are not selected from untrusted scopes, and keep operator actions within delegated scopes, thereby fixing all three problems (R1, R4, R5) simultaneously and strengthening the service's trust models.

The speakers also illustrated how Argus traces the impact of identified weaknesses. For instance, a simple identity handling weakness (the root cause) could be traced through a path (S1) to translate into significant consequences such as cross-tenant access, credential misuse, and broader authority than intended. The system could pinpoint the specific components where these trust assumptions were violated, providing a clear map from architectural flaw to potential exploit.

Furthermore, the "demo" of Argus's output included the automated generation of remediation strategies. For the identified issues, the system would propose:

  • Short-term containment: Immediate, near-term mitigations like tightening policies, disabling problematic behaviors, or adding enforcement mechanisms, designed to be deployed within hours.
  • Durable architectural fixes: Long-term solutions addressing the root cause, ensuring permanent elimination of the problem.
  • Validation criteria: Specific guidance on how to confirm that the proposed fixes are indeed working and cover the full surface of risk.

Through these detailed examples, the talk effectively demonstrated the conceptual power and practical utility of Argus, showcasing its ability to provide deep architectural understanding, root cause identification, impact analysis, and actionable remediation, all in an automated fashion.

Defensive Implications

▶ Watch: Results: High accuracy, nuanced findings, reviews in hours (24:30)

The Argus system presented by Microsoft offers profound implications for defensive security strategies, particularly for organizations managing large, complex cloud environments. Its adoption signals a necessary evolution in how security assurance is approached.

  1. Embrace AI for Proactive, Architectural Security: The most significant implication is the imperative to move beyond reactive vulnerability scanning and embrace AI-driven systems for proactive, architectural-level security assurance. Defenders must recognize that the sheer scale and pace of modern development and threats render manual, point-in-time reviews obsolete. Investing in agentic systems that can reason over architecture and context is no longer optional but essential for survival.
  1. Prioritize Context Maximization: The talk emphatically highlights that AI's effectiveness in security is directly proportional to the context it receives. Defenders have a strategic advantage with an "inside-out" view of their services. Organizations should focus on building robust data pipelines that feed their AI security tools with comprehensive internal data: source code, configurations, resource properties, service identities, network topology, and data flows. This rich context is crucial for achieving high accuracy and identifying nuanced, cross-domain issues that traditional tools miss.
  1. Shift Focus to Root Cause Analysis: Defenders should reorient their security efforts from merely patching symptoms to identifying and addressing root causes at an architectural level. Argus demonstrates that fixing a single underlying design flaw can eliminate entire classes of vulnerabilities (e.g., the identity handling weakness example). This approach leads to more durable security improvements and breaks the "whack-a-mole" cycle of vulnerability management.
  1. Automate Remediation and Validation: The ability of Argus to generate both short-term mitigations and durable architectural fixes, along with validation criteria, is a game-changer. Security teams should strive to integrate AI-driven remediation suggestions directly into their development and operational workflows. This dramatically shortens the path from "finding to mitigation to durable mitigation," allowing for rapid response to critical issues and efficient implementation of long-term fixes.
  1. Implement Continuous Security Assurance: The achievement of completing full assurance reviews within hours means that security assurance can become a continuous process rather than a periodic one. Organizations should aim to integrate such systems into their CI/CD pipelines, enabling frequent, rigorous reviews that keep pace with rapid code evolution and architectural changes, ensuring security posture remains current.
  1. Maintain Human-in-the-Loop Oversight: While automation is key, the speakers emphasized the importance of an "express human gate" for final review and approval. Defenders must design their AI security systems to augment, not replace, human experts. Human judgment remains critical for complex decisions, risk acceptance, and strategic oversight, ensuring that AI-generated outputs align with organizational security policies and priorities.
  1. Validate Architectural Understanding: Argus's capability to surface discrepancies between a service owner's perceived architecture and the actual deployed architecture is invaluable. Defenders should leverage AI systems to continuously validate and update their understanding of service topologies, trust boundaries, and data flows. This helps identify "architectural drift" and hidden assumptions that could be exploited.

In essence, the defensive implications of Argus point towards a future where security is deeply embedded, proactive, and continuously adaptive, driven by intelligent agents that extend the capabilities of human experts across vast and dynamic cloud landscapes.

Key Takeaways

  • The confluence of hyper-scale cloud environments (9,500+ services at Microsoft) and the collapse of the mean time to exploit (now negative, driven by AI assistance) necessitates a fundamental shift from reactive to proactive security assurance.
  • Traditional human-centric security assurance models, while architecturally sound, fail at scale due to bottlenecks in expert availability, time-consuming evidence gathering, and the inability to keep pace with rapid code and architectural evolution.
  • Microsoft's Argus system addresses this by employing agentic execution—using specialized AI agents to automate a human-inspired security workflow—and by maximizing context, leveraging defenders' unique inside-out view of services for high-fidelity analysis.
  • Argus excels at architecturally driven root cause analysis, identifying thematic issues rather than isolated vulnerabilities. This enables the implementation of durable fixes that eliminate entire classes of problems, significantly strengthening security posture.
  • The system automates the generation of both immediate short-term containment measures and durable architectural fixes, complete with validation criteria, drastically shortening the path from vulnerability discovery to effective remediation.
  • Early results demonstrate Argus's high accuracy (over 90% confirmed issues), its ability to uncover nuanced, cross-domain vulnerabilities that traditional tools miss, and its capacity to complete comprehensive assurance reviews within hours, enabling continuous security at cloud scale.

About the Speaker(s)

Salim Chawro works at Microsoft. In his role, he is actively involved in tackling the immense challenges of securing Microsoft's vast cloud infrastructure, particularly focusing on proactive defense strategies at scale. His work, as presented in this talk, highlights his expertise in identifying systemic security problems and exploring innovative, AI-driven solutions.

Zeeshan Syed also works at Microsoft. He plays a key role in the research, engineering, and rigorous evaluation of advanced security systems. His contributions to the Argus project underscore his deep technical knowledge in designing and implementing agentic frameworks and leveraging artificial intelligence to enhance cloud security assurance processes. Together, Salim and Zeeshan represent Microsoft's commitment to pioneering new frontiers in cybersecurity.

Reviews

Dr. Zero (Offensive Security Researcher) — WEAK

Microsoft engineers describe Argus, an agentic AI system for automated security assurance at cloud scale. The problem framing is sharp—9,500 services, negative MTTE, architectural context matters—but the talk never escapes the conceptual layer. No live demo, no real CVE, no failure modes, no adversarial evaluation. It's a well-structured vision deck, not a research talk.

Heather Calloway (CISO) — SOLID

This is a serious attempt to answer a real problem — how do you run security assurance at hyperscale when MTTE has gone negative? The architectural framing is right, and the root-cause-over-symptoms philosophy is exactly what mature programs need. But the talk stays at the altitude of design principles and synthetic examples; we don't see Argus find something real, get it wrong, or reveal its actual failure modes.

→ Top-rated talks at BlueHat Asia 2026

All talks from BlueHat Asia 2026