Back to Intelligence

NIST, CISA, and NSA: Runaway AI Agents Are Incidents — Identity Telemetry and Response Playbooks for 2026

SA
Security Arsenal Team
October 26, 2026
10 min read

A joint guide from NIST, CISA, and NSA — covered this week by BleepingComputer — formalizes something many of us in IR have been warning clients about for the past two years: an autonomous AI agent that exceeds its intended authority is not a bug to be patched, it is a security incident to be contained, investigated, and rehearsed. The guidance treats runaway agents with the same operational gravity as ransomware detonation or a compromised privileged account — because functionally, that's what they are.

The hard problem the agencies put their finger on is not detection of the agent's actions. It's attribution of authority. When an agent deletes a production database, exfiltrates a SharePoint library, or wires money through an ERP integration, the first question your IR team must answer is: whose credentials, whose delegated permissions, and whose approval chain did the agent act under? If that answer does not exist in your identity telemetry before the incident, it cannot be reconstructed during one. Delegation chains that aren't logged at issuance time are gone forever.

This post is the defensive playbook: what the guidance means technically, how to hunt for agent authority misuse today, and how to build the identity record that makes an agent incident survivable.

Technical Analysis: Why AI Agents Break Your Existing IR Model

The threat model

AI agents — LLM-driven automation built on frameworks like LangChain, AutoGen, Semantic Kernel, or vendor "copilot" platforms, frequently wired to tools via MCP (Model Context Protocol) servers — differ from traditional service accounts in one critical way: they make non-deterministic decisions with deterministic credentials. A classic service account executes a fixed script under a fixed identity. An agent interprets goals, chains tool calls, and can be steered — by prompt injection from attacker-controlled content, by poisoned retrieval data, or simply by ambiguous instructions — into performing actions its owner never intended, all while presenting perfectly valid authentication.

From your SIEM's perspective, every malicious action looks legitimate: valid OAuth tokens, valid API keys, valid Kerberos tickets. The failure is upstream, in authorization scope and intent — not in authentication.

Affected platforms and exposure surface

This is a cross-platform, architectural exposure — there is no CVE and no patch. The affected surface in a typical 2026 enterprise includes:

  • Microsoft 365 / Entra ID: Copilot Studio agents, Azure OpenAI-backed apps, and app registrations granted Graph permissions (Mail.Read, Sites.ReadWrite.All, Files.ReadWrite.All)
  • AWS: Bedrock Agents and Lambda-executed agent tooling running under IAM roles with broad s3:* or iam:PassRole permissions
  • Google Cloud: Vertex AI agents with service account keys
  • Endpoint-resident agents: developer workstations running MCP clients (e.g., mcp.json configs), local LLM tooling, and .env files holding long-lived API keys (OPENAI_API_KEY, ANTHROPIC_API_KEY)
  • SaaS automation: agents holding Personal Access Tokens (PATs) for GitHub, GitLab, Jira, Slack, Salesforce

The attack chain, from a defender's seat

  1. Authority acquisition: an agent is provisioned with a non-human identity (NHI) — an Entra service principal, IAM role, or API key — typically over-scoped at build time ("we'll tighten it later").
  2. Steering event: prompt injection via attacker-controlled email/web/document content, a compromised tool server (MCP), or a supply-chain-tainted model/plugin redirects the agent's behavior.
  3. Action on objectives: the agent executes tool calls — reading mailboxes, cloning repositories, modifying DNS, invoking payment APIs — under its valid NHI.
  4. Attribution failure: responders find clean authentication logs, no obvious compromise artifact, and no record of who delegated what authority to whom. Containment stalls because disabling the NHI may break production workflows nobody documented.

Exploitation status

Prompt injection against production agents, MCP server compromise, and theft of agent API keys from developer endpoints are all actively occurring techniques in 2026, not theory. There is no CISA KEV entry because there is no single CVE — the vulnerability is the absence of identity governance for NHIs. The NIST/CISA/NSA guidance exists precisely because incidents are already happening and organizations are arriving at them unprepared.

Detection & Response

The detections below target the two highest-fidelity signals in this threat class: (1) authority expansion — new credentials or permissions materializing on non-human identities, and (2) authority misuse — agent credentials exercised from anomalous contexts or local agent tooling touching sensitive material. Tune thresholds to your baseline; these are hunting rules, not fire-and-forget alerts.

YAML
---
title: Credential or Secret Added to Service Principal or App Registration
description: Detects addition of passwords or key credentials to Entra ID application or service principal objects — a primary authority-expansion vector for AI agent identities.
references:
  - https://www.bleepingcomputer.com/news/security/when-an-ai-agent-is-the-incident-the-identity-record-is-the-evidence/
  - https://attack.mitre.org/techniques/T1098/001/
author: Security Arsenal
date: 2026/04/06
status: experimental
tags:
  - attack.persistence
  - attack.t1098.001
logsource:
  product: azure
  service: auditlogs
detection:
  selection:
    operationName:
      - 'Add service principal credentials'
      - 'Update application - Certificates and secrets management'
      - 'Add app role assignment to service principal'
  condition: selection
falsepositives:
  - Legitimate DevOps credential rotation — correlate with change tickets
level: high
---
title: Long-Lived Access Key Created for IAM User
description: Detects creation of static AWS access keys, a common way agent integrations persist authority outside of short-lived role assumption.
references:
  - https://www.bleepingcomputer.com/news/security/when-an-ai-agent-is-the-incident-the-identity-record-is-the-evidence/
  - https://attack.mitre.org/techniques/T1098/001/
author: Security Arsenal
date: 2026/04/06
status: experimental
tags:
  - attack.persistence
  - attack.t1098.001
logsource:
  product: aws
  service: cloudtrail
detection:
  selection:
    eventSource: iam.amazonaws.com
    eventName:
      - CreateAccessKey
      - CreateLoginProfile
      - AttachUserPolicy
  condition: selection
falsepositives:
  - Onboarding automation — alert on keys created for accounts without a matching IAC pipeline run
level: medium
---
title: Interactive Logon or Shell Spawned by AI Agent Host Process
description: Detects agent framework runtimes (python, node) spawning interactive shells or credential access tooling on endpoints — consistent with a steered or compromised local agent.
references:
  - https://www.bleepingcomputer.com/news/security/when-an-ai-agent-is-the-incident-the-identity-record-is-the-evidence/
  - https://attack.mitre.org/techniques/T1059/
author: Security Arsenal
date: 2026/04/06
status: experimental
tags:
  - attack.execution
  - attack.t1059
logsource:
  category: process_creation
  product: windows
detection:
  selection_parent:
    ParentImage|endswith:
      - '\python.exe'
      - '\node.exe'
      - '\uv.exe'
      - '\npx.exe'
  selection_child:
    Image|endswith:
      - '\cmd.exe'
      - '\powershell.exe'
      - '\pwsh.exe'
      - '\whoami.exe'
      - '\net.exe'
  condition: all of selection_*
falsepositives:
  - Developer tooling and build scripts — scope to hosts with known agent/MCP deployments
level: medium
KQL — Microsoft Sentinel / Defender
// Hunt: Agent authority expansion followed by anomalous use
// Correlates new credentials/permissions on service principals with sign-ins from new IPs within 7 days
let credAdded = AuditLogs
| where TimeGenerated > ago(14d)
| where OperationName has_any ("Add service principal credentials", "Update application - Certificates and secrets management", "Add app role assignment to service principal")
| extend TargetSpn = tostring(TargetResources[0].displayName)
| project CredAddedTime=TimeGenerated, TargetSpn, InitiatedBy=tostring(InitiatedBy.user.userPrincipalName), OperationName;
let spSignins = AADServicePrincipalSignInLogs
| where TimeGenerated > ago(14d)
| project SigninTime=TimeGenerated, ServicePrincipalName=tostring(ServicePrincipalName), IPAddress, AppId, ResourceDisplayName;
credAdded
| join kind=inner spSignins on $left.TargetSpn == $right.ServicePrincipalName
| where SigninTime between (CredAddedTime .. CredAddedTime + 7d)
| summarize FirstUse=min(SigninTime), DistinctIPs=dcount(IPAddress), IPs=make_set(IPAddress), Resources=make_set(ResourceDisplayName)
  by TargetSpn, InitiatedBy, OperationName
| extend KnownIP = todynamic("REPLACE_WITH_BASELINE")
| sort by FirstUse asc;
// Secondary: broad Graph scope on app registrations granted in last 30 days
AuditLogs
| where TimeGenerated > ago(30d)
| where OperationName == "Consent to application" or OperationName == "Add app role assignment to service principal"
| mv-expand TargetResources
| mv-expand TargetResources.modifiedProperties
| where tostring(TargetResources_modmodifiedProperties.displayName) has "AppRoleAssignment"
| where tostring(TargetResources_modmodifiedProperties.newValue) has_any ("Sites.ReadWrite.All", "Mail.Read", "Files.ReadWrite.All", "Directory.ReadWrite.All", "Mail.Send")
| project TimeGenerated, OperationName, App=tostring(TargetResources.displayName), ConsentBy=tostring(InitiatedBy.user.userPrincipalName)
| sort by TimeGenerated desc
VQL — Velociraptor
-- Hunt for AI agent credential material and tool configs on endpoints
-- Targets .env files with LLM API keys and MCP client configurations
LET keyFiles = SELECT FullPath, Size, Mtime
FROM glob(globs=['C:/Users/*/.env', 'C:/Users/*/.claude*', 'C:/Users/*/.config/**/*mcp*', 'C:/Users/*/AppData/Roaming/Claude/*', 'C:/Users/*/*mcp*.json'])

LET agentProcs = SELECT Pid, Name, CommandLine, Exe, Username, CreateTime
FROM pslist()
WHERE CommandLine =~ '(?i)(mcp|langchain|autogen|openai|anthropic|agent)'
  AND Name =~ '(?i)(python|node|uv|npx)'

SELECT 'agent_process' AS ArtifactType, Name AS Detail1, CommandLine AS Detail2, Username AS Detail3, CreateTime AS Timestamp FROM agentProcs
UNION ALL
SELECT 'credential_file' AS ArtifactType, FullPath AS Detail1, format('%v bytes', Size) AS Detail2, '' AS Detail3, Mtime AS Timestamp FROM keyFiles
PowerShell
#Requires -Modules Microsoft.Graph.Identity.Applications, Microsoft.Graph.Identity.SignIns
# Audit Entra ID for over-privileged and freshly-credentialed agent identities
# Run as a scheduled task with an audit identity holding Application.Read.All, AuditLog.Read.All

Connect-MgGraph -Scopes "Application.Read.All","AuditLog.Read.All","Directory.Read.All" -NoWelcome

$report = @()
$highRiskScopes = @('Sites.ReadWrite.All','Mail.Read','Mail.Send','Files.ReadWrite.All','Directory.ReadWrite.All','Application.ReadWrite.All')
$cutoff = (Get-Date).AddDays(-30)

# 1. Service principals with credentials added in the last 30 days
Get-MgServicePrincipal -All | ForEach-Object {
    $sp = $_
    $sp.PasswordCredentials | Where-Object { $_.StartDateTime -gt $cutoff } | ForEach-Object {
        $report += [pscustomobject]@{
            Finding = 'RecentPasswordCredential'; DisplayName = $sp.DisplayName
            ObjectId = $sp.Id; Detail = "Secret created $($_.StartDateTime)"; Severity = 'High'
        }
    }
    $sp.KeyCredentials | Where-Object { $_.StartDateTime -gt $cutoff } | ForEach-Object {
        $report += [pscustomobject]@{
            Finding = 'RecentKeyCredential'; DisplayName = $sp.DisplayName
            ObjectId = $sp.Id; Detail = "Cert added $($_.StartDateTime)"; Severity = 'Medium'
        }
    }
}

# 2. App role assignments carrying high-risk Graph scopes
Get-MgServicePrincipal -All | ForEach-Object {
    $sp = $_
    Get-MgServicePrincipalAppRoleAssignment -ServicePrincipalId $sp.Id -All | ForEach-Object {
        $report += [pscustomobject]@{
            Finding = 'AppRoleAssignment'; DisplayName = $sp.DisplayName
            ObjectId = $sp.Id; Detail = $_.AppRoleId; Severity = 'Review'
        }
    }
}

$report | Sort-Object Severity, DisplayName | Format-Table -AutoSize
$report | Export-Csv -Path ".\AgentIdentityAudit_$(Get-Date -Format 'yyyyMMdd').csv" -NoTypeInformation
Write-Host "`nReview every 'High' finding against a change record. No ticket = treat as unauthorized authority expansion."

Remediation: Build the Identity Record Before You Need It

The NIST/CISA/NSA guidance is unambiguous on the ordering: governance artifacts must exist before deployment, not be assembled after the incident. Operational priorities:

  1. Inventory every non-human identity. Enumerate all Entra service principals, AWS IAM roles/users with static keys, GCP service accounts, SaaS PATs, and locally stored agent API keys (.env, MCP configs). Map each to a human owner, a business purpose, and an authority scope. An NHI without an owner is an incident waiting for a timestamp.
  2. Kill long-lived credentials. Replace static API keys and client secrets with workload identity federation, managed identities, or short-lived OAuth tokens (1-hour TTL). Where a vendor integration forces a static key, vault it, rotate on a 30-90 day cadence, and alert on any use from outside the expected network envelope.
  3. Enforce least authority at the tool layer. Agents should hold scoped, task-specific tokens — not tenant-wide Graph consent. Every Sites.ReadWrite.All grant to an agent identity should require a documented exception with an expiry date.
  4. Log the delegation chain. Record who approved, what scope, what expiry at credential issuance — in your CMDB or identity governance platform, not a spreadsheet. This is the identity record the guidance insists must pre-exist the incident. Your IR playbooks should treat this record as the first artifact pulled during triage.
  5. Build an agent kill-switch and rehearse it. Define the technical path to revoke an agent's tokens, disable its service principal, and sever its tool connections without taking down dependent production workflows. Then run the tabletop: "Agent X just emailed the entire customer table externally — walk the response." NIST/CISA/NSA explicitly call for rehearsal; treat it like your ransomware tabletop, because the blast radius math is identical.
  6. Detect authority expansion, not just use. Wire the Sigma/KQL detections above into your SIEM and route service-principal credential changes to the same severity queue as Domain Admin group modifications.
  7. Contain the prompt-injection vector. Filter and sandbox agent-consumed external content (email bodies, web pages, retrieved documents); treat MCP servers and agent plugins as third-party software subject to supply-chain review.

There is no vendor patch and no KEV deadline — the deadline is set by your own deployment velocity. Every agent you ship without an identity record is authority you cannot account for under pressure.

Related Resources

Security Arsenal Penetration Testing Services AlertMonitor Platform Book a SOC Assessment vulnerability-management Intel Hub

Is your security operations ready?

Get a free SOC assessment or see how AlertMonitor cuts through alert noise with automated triage.