Microsoft’s Project Perception Just Rewrote the Rules of Cyber Defense – Here’s How Red, Blue, and Green AI Agents Are Outpacing Hackers at Machine Speed + Video

By /

Listen to this Post

Featured Image

Introduction

The physics of cybersecurity are undergoing a fundamental shift. Autonomous systems can now reason, adapt, and operate continuously, while the cost of offense is falling and the volume, velocity, and complexity of what must be secured continues to grow exponentially. Attackers can generate exploits faster, scale campaigns further, and operate with unprecedented efficiency using AI-driven tooling. The approaches built for a world of human defenders simply cannot keep pace with a world of AI, agents, and machine-speed attacks. Enter Project Perception – Microsoft’s new agentic security system designed to turn signals into real-time protections using AI to defend against AI.

Learning Objectives

  • Understand the architecture and operational mechanics of multi-agent security systems, including the distinct roles of Red, Blue, and Green team agents.
  • Learn how to leverage AI-driven vulnerability discovery and remediation pipelines (MDASH) to reduce mean time to detection and response.
  • Acquire practical command-line and configuration skills for implementing agentic security workflows across Linux, Windows, and cloud environments.
  1. The New Cyber Stack: Red, Blue, and Green Agents in a Closed-Loop System

Project Perception is built on a simple but powerful idea: effective defense requires continuous understanding of how an attacker sees the world, how a defender evaluates risk, and how protections are improved over time. To accomplish this, Perception coordinates three classes of specialized agents that form a closed-loop system:

  • Red Team Agents identify potential paths to compromise before an attacker can exploit them. They probe like an attacker, performing continuous adversarial simulations across identities, endpoints, applications, data, clouds, and AI systems.
  • Blue Team Agents investigate, reason over context, and determine what represents meaningful risk. They operate like your best incident responder, triaging alerts, correlating signals, and separating noise from genuine threats.
  • Green Team Agents take corrective actions and strengthen defenses across the environment. They remediate vulnerabilities, apply patches, update firewall rules, and harden configurations – all without requiring a human hand-off at every step.

Step‑by‑step: How to Simulate This Agentic Workflow in Your Own Environment

While Project Perception is a Microsoft platform, you can replicate the logic of this closed-loop system using open-source tools and custom scripting:

  1. Set up a Red Team simulation using tools like Metasploit, Caldera, or Atomic Red Team. Run automated penetration tests against a staging environment: 
    Linux – Launch a Metasploit auxiliary scanner against a target subnet
msfconsole -q -x "use auxiliary/scanner/portscan/tcp; set RHOSTS 192.168.1.0/24; set THREADS 50; run; exit"

    Windows – Use Invoke-AtomicRedTeam to simulate TTPs
Import-Module "C:\AtomicRedTeam\invoke-atomicredteam.ps1"
Invoke-AtomicTest T1218 -TestNumbers 1

  2. Deploy a Blue Team monitoring stack – Elastic SIEM, Wazuh, or Splunk – to ingest logs, detect anomalies, and generate alerts:

    Linux – Install Wazuh agent and forward logs to a central manager
curl -s https://packages.wazuh.com/key/GPG-KEY-WAZUH | apt-key add -
echo "deb https://packages.wazuh.com/4.x/apt/ stable main" | tee /etc/apt/sources.list.d/wazuh.list
apt-get update && apt-get install wazuh-agent
systemctl start wazuh-agent

  3. Implement a Green Team remediation engine using Ansible, Puppet, or custom PowerShell scripts that automatically apply fixes based on detection rules:

    Ansible playbook to remediate a known CVE</p></li>
</ol>

<p>- name: Apply critical security patch
hosts: all
tasks:
- name: Ensure patch KB5012170 is installed
win_updates:
category_names:
- SecurityUpdates
whitelist:
- KB5012170
when: ansible_os_family == "Windows"
    1. Close the loop by feeding remediation outcomes back into your Red Team tools to verify that the fix is effective, then updating your detection rules accordingly.

    2. MDASH: The Multi-Model Agentic Scanning Harness

    At the heart of Microsoft’s new security strategy is MDASH (Multi-model Agentic Scanning Harness) – an AI-powered pipeline that orchestrates over 100 specialized agents across an ensemble of frontier and distilled models. Rather than relying on a single AI model, MDASH runs a staged workflow: a scanner pipeline first identifies candidate vulnerabilities across critical binaries, then validates findings, and finally assesses exploitability.

    MDASH is designed as a model-agnostic system that uses bespoke AI agents for different vulnerability classes to autonomously discover, validate, and prove exploitable defects in complex codebases like Windows. Microsoft has built dedicated cloud-based scanning and validation pipelines for MDASH to identify vulnerabilities at scale, reduce false positives, and get high-confidence issues to engineers faster – shrinking the opportunity for malicious actors to launch zero-day attacks.

    Step‑by‑step: Integrating AI-Assisted Vulnerability Scanning into Your CI/CD Pipeline

    While MDASH itself is not open-source, you can integrate AI-assisted security scanning into your development workflow using available tools:

    1. Integrate GitHub Advanced Security with CodeQL for semantic code analysis: 
      In your GitHub Actions workflow</li>
</ol>

- name: Initialize CodeQL
uses: github/codeql-action/init@v3
with:
languages: 'javascript, python'
- name: Perform CodeQL Analysis
uses: github/codeql-action/analyze@v3
      1. Use Semgrep for fast, rule-based static analysis with AI-enhanced rules: 
        Install Semgrep and run a scan
pip install semgrep
semgrep --config auto --output semgrep_report.json .

      2. Deploy a local LLM-based vulnerability assistant using Ollama + a fine-tuned cybersecurity model:

        Pull a security-focused model and analyze a code snippet
ollama pull wizard-coder
echo "Analyze this Python function for SQL injection vulnerabilities: \n $(cat app.py)" | ollama run wizard-coder

      3. Automate ticket creation for validated findings using your SIEM or ticketing system:

        Python script to create Jira tickets from scan results
import requests
for finding in findings:
if finding['severity'] == 'critical':
requests.post('https://your-jira-instance/rest/api/2/issue/', json={
'fields': {
'project': {'key': 'SEC'},
'summary': f"Vulnerability: {finding['name']}",
'description': finding['description'],
'issuetype': {'name': 'Bug'}
}
})

      3. MAI-Cyber-1-Flash: The Specialized Cyber Model

      Project Perception adopts a multi-model architecture that combines frontier and specialized cyber models, optimizing for both quality and cost. The first scenario is software vulnerability management, bringing MAI-Cyber-1-Flash inside MDASH.

      MAI-Cyber-1-Flash is a specialized cybersecurity model designed to handle up to 90% of security tasks efficiently, while MDASH escalates the remaining 10% of exceptionally difficult problems to a larger frontier model – OpenAI’s GPT-5.4. This hybrid approach delivers 96% on CyberGym (an industry-leading benchmark), +12 points above Anthropic’s Mythos, while achieving almost 50% cost savings compared to the previous MDASH configuration.

      > Step‑by‑step: Building a Cost-Optimized Multi-Model Security Pipeline

      You can apply the same “cheap model for most tasks, expensive model for hard cases” principle using open-source and commercial LLMs:

      1. Set up a routing layer that classifies incoming security queries by complexity: 
        Python routing logic
def route_query(query):
complexity_score = analyze_complexity(query)  e.g., length, technical depth
if complexity_score < 0.3:
return "fast_model"  e.g., Mistral-7B
elif complexity_score < 0.7:
return "medium_model"  e.g., Llama-3-70B
else:
return "frontier_model"  e.g., GPT-4 or Claude

      2. Deploy a local fast model for log analysis and pattern matching:

        Run a lightweight model with Ollama
ollama run mistral "Analyze this firewall log for suspicious patterns: $(cat firewall.log)"

      3. Use a commercial API only for the most challenging 10% of queries:

        Call OpenAI API only for high-complexity cases
curl https://api.openai.com/v1/chat/completions \
-H "Authorization: Bearer $OPENAI_API_KEY" \
-H "Content-Type: application/json" \
-d '{"model": "gpt-4", "messages": [{"role": "user", "content": "Perform deep CVE analysis on this binary..."}]}'

      4. Monitor cost and performance using a simple logging framework:

        import time
start = time.time()
response = call_model(query, model_type)
elapsed = time.time() - start
log_metric(model_type, elapsed, response.quality)

      5. CyberGym: The Benchmark That Separates the Best from the Rest

      CyberGym is the primary benchmark used to evaluate AI agents’ real-world cybersecurity capabilities at scale. It measures a model’s ability to generate working proof-of-concept exploits for known software vulnerabilities. Microsoft’s combined system – MAI-Cyber-1-Flash inside MDASH – scored 96% on CyberGym, outperforming competitors from Anthropic, Google, and OpenAI.

      Step‑by‑step: How to Evaluate Your Own Security AI Systems

      If you’re building or evaluating AI security tools, consider implementing a CyberGym-style evaluation pipeline:

      1. Curate a test set of CVEs with known exploits. The NVD (National Vulnerability Database) provides structured data: 
        Download CVE data via the NVD API
curl -X GET "https://services.nvd.nist.gov/rest/json/cves/2.0?resultsPerPage=100" -o cves.json

      2. Create a harness that feeds vulnerability descriptions to your AI model and asks it to generate an exploit proof-of-concept:

        def evaluate_model(model, cve_entry):
prompt = f"Given this vulnerability: {cve_entry['description']}, generate a working exploit PoC."
response = model.generate(prompt)
return validate_exploit(response, cve_entry['cve_id'])

      3. Score your model based on the percentage of CVEs for which it can produce a valid, working exploit.

      4. Iterate by fine-tuning your model on successful exploit patterns and retesting.

      5. Cloud Hardening and API Security in the Agentic Era

      As agentic systems like Project Perception become more prevalent, organizations must also harden their cloud and API surfaces. The same AI that defends can also be used to attack – and API endpoints are a prime target.

      > Step‑by‑step: Hardening Cloud APIs Against AI-Powered Attacks

      1. Implement rate limiting and anomaly detection using a cloud-1ative WAF: 
        AWS WAF rate-based rule via CLI
aws wafv2 create-rule-group --1ame RateLimitRule --scope REGIONAL \
--rules '{"Name":"RateLimit","Priority":0,"Statement":{"RateBasedStatement":{"Limit":1000,"AggregateKeyType":"IP"}},"Action":{"Block":{}}}'

      2. Use API gateways with authentication and authorization – OAuth2, JWT, or mTLS:

        Generate a self-signed certificate for mTLS
openssl req -x509 -1ewkey rsa:4096 -keyout key.pem -out cert.pem -days 365 -1odes

      3. Deploy a secrets management solution (e.g., HashiCorp Vault) to rotate credentials automatically:

        Vault CLI – enable a secrets engine and generate a dynamic database credential
vault secrets enable database
vault write database/config/my-db plugin_name=postgresql-db-plugin \
allowed_roles="my-role" connection_url="postgresql://{{username}}:{{password}}@localhost:5432/mydb"
vault write database/roles/my-role db_name=my-db creation_statements="CREATE USER \"{{name}}\" WITH PASSWORD '{{password}}' VALID UNTIL '{{expiration}}';"

      4. Automate security group updates based on threat intelligence feeds:

        Python script to block malicious IPs using AWS SDK
import boto3
ec2 = boto3.client('ec2')
malicious_ips = fetch_threat_intel()
for ip in malicious_ips:
ec2.authorize_security_group_ingress(
GroupId='sg-12345678',
IpPermissions=[{'IpProtocol': 'tcp', 'FromPort': 0, 'ToPort': 65535, 'IpRanges': [{'CidrIp': f'{ip}/32'}]}]
)

      5. Linux and Windows Commands for Agentic Security Operations

      Security teams managing hybrid environments need a solid command-line foundation. Below are essential commands for both Linux and Windows that align with the continuous discovery, evaluation, and improvement loop of agentic systems.

      Linux – Discovery and Hardening

       Audit open ports and listening services
ss -tulpn

Check for world-writable files (a common misconfiguration)
find / -type f -perm -0002 -ls 2>/dev/null

Review sudoers for excessive privileges
visudo -c

Monitor real-time system calls for suspicious activity
auditctl -a always,exit -S execve -k process_exec
ausearch -k process_exec --start recent

Use Lynis for automated security auditing
lynis audit system

      Windows – Discovery and Hardening (PowerShell)

       Get all listening ports and associated processes
Get-1etTCPConnection | Where-Object {$_.State -eq 'Listen'}

Check for missing security patches
Get-WindowsUpdate -MicrosoftUpdate

Review local group memberships for privileged accounts
Get-LocalGroupMember -Group "Administrators"

Enable advanced audit logging
auditpol /set /subcategory:"Process Creation" /success:enable /failure:enable

Use PowerSploit or similar for red-team simulation (in a controlled lab)
Import-Module .\PowerSploit\PowerSploit.psd1
Invoke-Mimikatz -DumpCreds

      Cross-Platform – API Security Testing

       Use OWASP ZAP for automated API security scanning
zap-cli quick-scan --self-contained --start-options "-config api.disablekey=true" https://your-api-endpoint.com

Use Nuclei for template-based vulnerability scanning
nuclei -target https://your-api-endpoint.com -t ~/nuclei-templates/http/

Use Burp Suite's headless mode for CI/CD integration
java -jar burp.jar --headless --config=burp_config.json --target=https://your-api-endpoint.com

      7. The Human Element: Governance and Responsible AI

      Project Perception emphasizes that while agents handle the heavy lifting, humans remain firmly in control. Every high-impact action still requires human approval, and enterprise-grade governance ensures every decision is scoped, traceable, and replayable. This is not about replacing security professionals – it’s about amplifying them with better insights and more powerful ways to act.

      > Step‑by‑step: Establishing Governance for Agentic Security Systems

      1. Define approval workflows for critical actions (e.g., production patching, firewall changes): 
        Pseudo-code for an approval gate
if action.severity == 'critical':
ticket = create_approval_ticket(action)
wait_for_approval(ticket.id)
execute_action(action)

      2. Implement full audit logging for all agent decisions and actions:

        Linux – Send all agent logs to a central SIEM
logger -t agentic-system "Red team identified CVE-2026-1234 at $(date)"

      3. Conduct regular red-team exercises to test both the agents and the human response procedures.

      4. Establish a feedback loop where human analysts can retrain or override agent decisions, feeding those corrections back into the model training pipeline.

      What Undercode Say

      • Key Takeaway 1: The cybersecurity industry is transitioning from alert-based to action-based defense. Systems like Project Perception don’t just tell you about threats – they autonomously investigate, prioritize, and remediate them. This shifts the security team’s role from firefighting to strategic oversight.

      • Key Takeaway 2: Cost optimization is a critical success factor. MAI-Cyber-1-Flash’s 50% cost savings over previous configurations prove that specialized, smaller models handling routine tasks – with frontier models reserved for the hardest 10% – is the economically sustainable path forward for AI-driven security.

      • Analysis: Microsoft’s announcement on July 27, 2026, represents a pivotal moment in enterprise security. The integration of MDASH with Microsoft Defender and GitHub Code Security means that agentic defense is no longer theoretical – it’s being baked into the tools that organizations already use. However, this also raises the stakes: as defenders adopt AI, attackers will too. The arms race is accelerating, and organizations that fail to adopt agentic capabilities will find themselves increasingly outmatched. The key differentiator will not be the model itself, but the quality of telemetry, the richness of organizational context, and the governance frameworks that keep human judgment at the center.

      Prediction

      • +1 Agentic security systems will become the default architecture for enterprise security within 24–36 months, reducing mean time to remediation from days to minutes and making zero-day exploitation significantly harder.

      • +1 The “cheap model for most, expensive model for hard cases” architecture will become the industry standard, driving down the total cost of AI-powered security and making it accessible to mid-market organizations.

      • -1 The same multi-agent frameworks will be weaponized by sophisticated adversaries, leading to a new class of AI-vs-AI cyber conflicts where offensive and defensive agents engage in continuous, machine-speed battles.

      • -1 Organizations that lack the telemetry and data hygiene required to feed these systems will fall behind, creating a widening gap between security haves and have-1ots.

      • +1 The human role in security will evolve from tactical execution to strategic oversight, with security professionals spending more time on threat hunting, policy design, and AI governance – and less time on repetitive triage and patching.

      • -1 Regulatory frameworks will struggle to keep pace with agentic systems, particularly around accountability, liability, and data privacy when autonomous agents take actions that have real-world consequences.

      ▶️ Related Video (58% Match):

      https://www.youtube.com/watch?v=0nNsOrKYxdM

      🎯Let’s Practice For Free:

      🎓 Live Courses & Certifications:

      Join Undercode Academy for Verified Certifications

      🚀 Request a Custom Project:

      Secure, high-velocity infrastructure and disruptive technological engineering. Contact our engineering team for high-tier development and proprietary systems:
      [email protected]
      💎 Smart Architecture | 🛡️ Secure by Design | ⭐ Trusted by Thousands

      IT/Security Reporter URL:

      Reported By: Markolauren Agenticloop – Hackers Feeds
      Extra Hub: Undercode MoN
      Basic Verification: Pass ✅

      🔐JOIN OUR CYBER WORLD [ CVE News • HackMonitor • UndercodeNews ]

      💬 Whatsapp | 💬 Telegram

      📢 Follow UndercodeTesting & Stay Tuned:

      𝕏 formerly Twitter 🐦 | @ Threads | 🔗 Linkedin | 🦋BlueSky

Related Posts: