Mandiant Outlines Guardrails for AI-Assisted Vulnerability Management

· Original article ↗

Summary

Mandiant recommends combining AI agents with deterministic controls and human oversight to manage vulnerabilities safely, including sandboxing agents, restricting privileges, validating findings, and reviewing AI-generated fixes.

Key points

  • Treat code, third-party dependencies, and agent integrations as untrusted inputs; filter prompt injections and sensitive data before they reach agents.
  • Run agents in isolated, unprivileged environments with narrowly scoped, short-lived credentials, and monitor and log their actions.
  • Use risk-based vulnerability management to prioritize findings by vulnerability severity, asset context, and real-world threat activity.
  • AI agents are better suited to vulnerabilities with clear, observable outcomes; complex business-logic flaws still require human architectural review.
  • Require reproducible tests in monitored sandboxes to validate agent findings, with timeouts and iteration limits to control resource use.
  • Keep human review for findings and AI-generated fixes; use regression tests, rollback controls, and audit logs before and after deployment.
  • Maintain foundational security controls and deterministic SAST/DAST, since AI-assisted discovery does not guarantee complete coverage.

Article Details

Defense Focus
Safely integrate AI agents into vulnerability discovery and remediation using isolation, least privilege, deterministic validation, human review, and risk-based prioritization.
Detection Methods
  • Normalize and deduplicate findings from EASM, CSPM, CTEM, and traditional scanners; enrich them with current asset context and threat intelligence to prioritize remediation.
  • Use SAST and DAST for baseline code checks, and reserve intensive AI-agent audits for high-impact components where findings can be validated with observable outcomes.
  • Require agents to produce reproducible test harnesses and run them automatically in isolated, monitored sandboxes with execution timeouts and iteration limits.
  • Have a human review sandbox-confirmed findings for reachability, environmental context, and business impact.
  • Monitor agent inputs, actions, reasoning, and outputs at runtime; use centralized logging to trace and restrict data flows to external endpoints.
  • Monitor production workload behavior and the runtime libraries executing in production, not only static software inventories.
Data Sources
  • Normalized vulnerability findings from traditional scanners, EASM, CSPM, and CTEM
  • Updated CMDB and asset context, including exposure and data sensitivity
  • Threat intelligence and exploitation telemetry, including EPSS probabilities
  • Source code, dependencies, and SAST findings
  • Sandbox execution results and deterministic test-harness outcomes
  • Runtime workload and library telemetry
  • AI-agent inputs, actions, outputs, and audit logs
Rule Types
  • Deterministic SAST and DAST checks
  • Deterministic policy-engine controls
  • Schema validation for inbound application and API traffic
  • Automated regression tests and exploit-validation test harnesses
  • Weighted risk-based vulnerability scoring
Platforms
  • Isolated, monitored sandboxes
  • CI/CD pipelines and runners
  • IDE-integrated development environments
  • EDR platforms
  • SOAR platforms
Defensive Actions
  • Keep agents away from sensitive data; test with synthetic data in non-production environments and filter sensitive data and malicious prompt injections before they reach agents.
  • Treat code, third-party dependencies, skills, and MCP integrations as untrusted inputs; vet tool integrity and monitor agent behavior at runtime.
  • Run agents in isolated, unprivileged containers with dynamically limited privileges; use distinct, scoped machine identities and short-lived, repository- and branch-bound tokens.
  • Use zero-data-retention agreements with LLM providers and establish authorized testing rules of engagement.
  • Apply human-led threat modeling during design and architecture reviews, and red-team AI agents before deployment.
  • Prioritize remediation using current asset context and threat intelligence; enforce patching SLOs and document risk acceptance for exceptions.
  • Restrict remediation agents to proposing pull requests; run regression suites and the original proof-of-concept against proposed fixes, then require human approval.
  • Use immutable audit logs, pin model API versions, and maintain deterministic regression suites and automated rollback capability.

People

Vendors

Products

Related Articles