Enterprises can scale AI agents responsibly when they understand which agents are active, what tools and data they can access, and which actions they are attempting to take. Agents also change the impact of a security failure. A chatbot that gets something wrong produces a bad answer, while an agent that gets something wrong can delete a record, send a file, call an unapproved tool or spend a budget. Agentic AI risk management therefore has to cover unauthorized actions as well as harmful outputs.
A seven-step framework covers agentic AI risk management, moving from inventory to scoring, oversight policy, technical guardrails, pre-deployment testing, monitoring and incident response. Four roles own the work: the chief information security officer (CISO), who owns enterprise risk posture and board reporting; the AI governance and compliance lead, who turns policy into enforceable, auditable controls; the cloud or network security architect, who decides where controls sit and how traffic reaches them; and the cloud financial operations (FinOps) lead, who has to make agent spend visible and defensible.
Key takeaways
- The framework runs in seven steps, from inventory and risk scoring to incident response and re-scoring.
- Gate irreversible actions with deterministic authorization. Use intent-based policy enforcement to catch misuse that rules alone cannot express.
- In audit trails, human-to-agent attribution can link observed agent activity to the human who initiated it, where identity and execution context are available. That record is the core audit evidence.
- Re-score agents after model swaps, new tools, Model Context Protocol (MCP) servers, or incidents.
- Cost per successful outcome gives FinOps leads a unit measure for agent spend.
What is agentic AI risk management?
Agentic AI risk management is the practice of discovering and inventorying AI agents across available enterprise visibility sources, deciding how much autonomy each one may have, enforcing that decision through appropriate runtime controls, and establishing an auditable record of what each agent did and on whose behalf, mapped to the National Institute of Standards and Technology (NIST) AI Risk Management Framework (AI RMF) GOVERN, MAP, MEASURE and MANAGE functions. It covers the agent’s model, tools, credentials, the data it can reach and the MCP servers it connects to.
How agent risk differs from large language model and chatbot risk
Agents expand the attack surface from a single prompt and response to every input the agent reads and every action it can take. Four properties drive the difference.
- Tool access: An agent calls APIs, queries databases and invokes MCP tools, so tool responses and tool descriptions become inputs an attacker can shape. The joint agentic AI guidance from CISA, NSA and Five Eyes partners recommends validating tool responses and standardizing tool descriptions to avoid persuasive language.
- Autonomy: The same guidance notes that agentic systems can act without explicit human approval, which raises the chance that insecure actions happen without oversight. Step 3 approval gates restore that oversight for high-impact actions.
- Memory and context persistence: OWASP’s Top 10 for Agentic Applications separates goal hijacking from “the persistent corruption of stored context or long-term memory,” which can skew decisions across sessions. A poisoned memory entry can keep redirecting the agent long after the original input is gone.
- Multi-step actions: OWASP describes cascading failures as “the propagation and amplification of an initial fault… across agents, tools, and workflows, turning a single error into system-wide impact.” One compromised step can trigger actions in tools and agents the attacker never touched.
In practice, a large language model (LLM) risk program asks whether an output is harmful. An agent program also asks whether the action was authorized, by whom, with which credential, and whether it can be reversed.
Why traditional risk frameworks break down
Traditional AI governance practices remain essential, but they are insufficient on their own for systems that can independently execute actions. Reviewing a model or use case before deployment, documenting an approved scope and periodically reassessing risk establish the governance foundation. Agents introduce an additional requirement: that approved scope must be enforced as individual actions occur. The gap between what was approved and what actually runs appears in three ways:
- Static versus dynamic: Teams add tools and swap models, so agent behavior changes between reviews. In a June 2026 Gartner article, Avivah Litan argues that organizations must move from policy-based governance to enforceable technical controls as AI scales.
- Reactive versus proactive: Periodic audits find problems after an agent has acted. Gartner predicts that by 2027, 40% of enterprises will demote or decommission autonomous agents because of governance failures identified only after production incidents.
- Documentation versus evidence: In a CSA survey commissioned by Strata Identity of 285 IT and security professionals, conducted in September and October 2025, 84% of organizations doubted they could pass a compliance audit focused on agent behavior or access controls. Policy documents alone cannot show what an agent actually did.
Closing these gaps takes an audit trail that proves three things: what was approved, what actually ran and whether each step stayed inside the allowed boundary.
The agentic AI risk taxonomy
Agent risks fall into four groups: attack vectors, agent behavior failures, business outcomes and governance gaps. The taxonomy follows the OWASP Top 10 for Agentic Applications 2026, published December 9, 2025 and developed with more than 100 industry experts, and uses OWASP’s category identifiers (ASI01 to ASI10).
| Category | Risk (OWASP reference) | Example | Business impact |
|---|---|---|---|
| Attack vector | Prompt injection, direct and indirect (ASI01 Agent Goal Hijack) | OWASP’s Q2 2026 exploit roundup tags an incident where “review or triage became credential extraction” | Agent goals redirected; credentials and data exposed |
| Attack vector | Memory and context poisoning (ASI06) | the OWASP GenAI Security Project’s Q3 2026 exploit roundup tags an incident where “planted agent configuration could execute when a repository was opened” | Corruption persists across sessions and users |
| Attack vector | Tool or data poisoning (ASI02; LLM04:2025 Data and Model Poisoning) | A poisoned document placed in a retrieval knowledge base | Agent acts on false data or hidden instructions |
| Attack vector | Compromised third-party MCP servers (ASI04 Agentic Supply Chain Vulnerabilities) | OWASP’s December 2025 Top 10 benchmark post cites a GitHub MCP exploit for ASI04 | Trusted tools become a delivery path for attacks |
| Agent behavior | Unauthorized tool use (ASI02 Tool Misuse & Exploitation) | Misuse “triggered through delegation, orchestration, or chain-of-command misuse,” per OWASP’s multi-agent threat modelling guide | Actions run within permissions but outside intent |
| Agent behavior | Privilege escalation (ASI03 Identity & Privilege Abuse) | OWASP’s Q3 2026 roundup: “stolen OIDC and publishing credentials enabled propagation” | Blast radius extends beyond the agent’s task |
| Agent behavior | Runaway loops (ASI02, threat T4 Resource Overload) | Two agents re-trigger each other with no iteration cap | Spend and capacity consumed with no output |
| Agent behavior | Cascading failures across multi-agent systems (ASI08) | OWASP’s Q3 2026 roundup: “worker compromise propagated to connected infrastructure” | One fault becomes a system-wide outage |
| Agent behavior | Agent-to-agent trust abuse (ASI07 Insecure Inter-Agent Communication) | OWASP’s Agentic AI Threats and Mitigations guide, threat T12: “The attacker injects false information into inter-agent communications, leading to incorrect financial decisions” | Downstream agents act on poisoned instructions |
| Business outcome | Data exfiltration | MITRE ATLAS’s 2025-09 update added “Exfiltration via AI Agent Tool Invocation” as a technique | Regulated data, IP and customer records leave the enterprise |
| Business outcome | Runaway spend (usually the result of runaway loops) | The FinOps Foundation’s FinOps for AI overview lists agent loops among the AI cost anomalies to watch, alongside prompt changes that double token use | Unbudgeted token and cloud costs |
| Governance gap | Shadow agents | Agents that business teams build or connect without entering any register | Agents operate outside every control above |
| Governance gap | Non-human identity and credential sprawl | A Gartner survey of 335 identity and access management (IAM) leaders, conducted August to October 2024, found IAM teams responsible for 44% of organizational machine identities | Credentials that no team owns, rotates or revokes |
The seven-step agentic AI risk management framework
The framework closes the gap between what was approved and what actually runs by taking each agent through seven steps, from finding it to proving what it did. Each step answers one question and produces one deliverable that the next step depends on.
| Step | Question it answers | Deliverable |
|---|---|---|
| 1. Inventory agents, tools and autonomy levels | Which agents exist, and what can each one reach? | Agent register |
| 2. Classify and score agent risk | Which agents need governing first? | Risk-scored register |
| 3. Set autonomy tiers and human oversight gates | What may each agent do on its own, with approval, or never? | Approved autonomy policy |
| 4. Engineer guardrails and technical controls | How is that policy enforced before an action runs? | Inline controls |
| 5. Test agents before deployment | Do the controls hold under attack? | Test report and go-live sign-off |
| 6. Monitor, audit and attribute agent actions | What did each agent actually do, and on whose behalf? | Audit trails with human-to-agent attribution |
| 7. Respond to agent incidents and re-score | How fast can a misbehaving agent be stopped, and what changes afterward? | Incident playbook and updated register |
Steps 1 and 2 establish visibility and priority. Steps 3 and 4 decide what each agent may do and enforce it inline, and Step 5 proves those controls hold before go-live. Steps 6 and 7 cover production: monitoring shows what agents actually did, and incident response sends affected agents back to Step 2 for re-scoring. Model swaps, new tools and new data access do the same, so the framework runs as a continuous loop rather than a one-time review.
The steps also answer the four risk groups in the taxonomy. Steps 1 and 2 surface governance gaps such as shadow agents and unowned credentials. Steps 3 and 4 constrain agent behavior failures. Step 4’s runtime inspection and Step 5’s testing address attack vectors. Steps 6 and 7 limit business outcomes such as exfiltration and runaway spend. Each step has one accountable owner, set out in the next section.
Who owns agent risk
Agent risk needs one accountable executive and a named owner for each of the seven steps. In ISACA’s 2026 AI Pulse Poll of more than 3,400 digital trust professionals, 20% did not know who would be ultimately responsible if an AI system caused harm; 28% pointed to the board or executives, 18% to the chief information officer (CIO) or chief technology officer (CTO) and 13% to the CISO. A Cloud Security Alliance (CSA) study commissioned by Aembit, a survey of 228 IT and security professionals conducted in January 2026, found security leads agent identity and access in 28% of organizations, development in 21%, IT in 19% and IAM teams in only 9%.
We recommend starting from a responsible, accountable, consulted, informed (RACI) matrix that gives each step one accountable owner:
| Step | CISO | AI governance lead | Network architect | FinOps lead | Product and model owners |
|---|---|---|---|---|---|
| 1. Inventory | A | R | R | C | R |
| 2. Classify and score | A | R | C | C | R |
| 3. Autonomy tiers and oversight | C | A, R | C | C | R |
| 4. Guardrails and controls | A | C | R | C | R |
| 5. Test before deployment | A | C | C | I | R |
| 6. Monitor and attribute | A | R | R | R (spend) | C |
| 7. Respond and re-score | A | R | R | C | R |
A cross-functional AI risk committee should approve the autonomy policy in Step 3 and review key performance indicator (KPI) reporting quarterly. Gartner recommends fusion teams that create shared responsibility for business value, operational support and risk management. The IAPP AI Governance Skills Framework adds a practical caution: most organizations will assign two or more governance functions to one role, so the matrix should name the people assigned to each title.
Step 1: Inventory agents, tools and autonomy levels
You cannot score, govern or attribute an agent you have not found, so Step 1 produces an agent register that lists every agent, its tools, its credentials and its current autonomy level. WitnessAI estimates that enterprises use up to five times more AI tools than they realize. That ratio is a first-party benchmark until independent research confirms it.
The register should capture five fields per agent:
- Shadow AI and agent discovery: Find agents from network traffic, identity logs and cloud platforms, including agents embedded in desktop apps, IDEs and browsers. Agents embedded in tools employees already use rarely appear in procurement records.
- MCP servers: MCP visibility means recording every MCP server each agent connects to, the tools it exposes, and whether the server is first-party, vetted third-party or unknown. Unknown servers are the first to block or review.
- Tool access mapping: List each tool the agent can call and whether it reads, writes, deletes or spends. A tool that writes, deletes or spends raises the agent’s Step 2 score.
- Non-human identities and credentials: Record the service accounts, API keys and tokens each agent holds, plus their lifetime and owner. Long-lived keys with no owner are the credentials most likely to outlive the agent.
- Current autonomy level: Record what the agent does today without human approval. This baseline is what the risk score and any later autonomy limits are measured against.
The network architect usually owns discovery mechanics, and the governance lead owns the register. The NIST AI RMF names this work directly: GOVERN 1.6 in NIST AI 100-1 calls for “Mechanisms… to inventory AI systems”.
WitnessAI Observe supports this step with network-level visibility into AI applications, agentic activity and MCP servers observed through the platform. AI applications can be matched against WitnessAI’s catalog of more than 5,000 applications, while agent activity and MCP connections provide visibility into the tools being accessed. AI interactions can also be classified by risk and intent. Agents outside the observed network paths require complementary discovery through identity logs, cloud platform inventories or Witness Anywhere for supported off-network deployments.
Deliverable: an agent register with owner, tools, MCP servers, credentials and current autonomy level for every agent.
Step 2: Classify and score agent risk
A register tells you which agents exist; a score tells you which ones to govern first. Rating each agent’s current autonomy against what it could break turns the register into a risk-scored register. The joint Five Eyes guidance, Careful Adoption of Agentic AI Services, recommends classifying agent actions “by potential impact, likelihood and reversibility” and applying safeguards accordingly.
Score each agent on four inputs:
| Input | What to assess | Example of high risk |
|---|---|---|
| Current autonomy | Actions taken today without approval | Executes writes and sends externally with no review |
| Action impact | Reversibility and blast radius of the worst permitted action | Deletes records, changes production, moves money |
| Permission scope | Breadth and lifetime of credentials | Standing access to production with long-lived keys |
| Data sensitivity | Classification of data the agent reads or writes | Cardholder data, health data, customer PII |
Governance leads should keep the scoring method simple and documented. Schellman’s guide to ISO 42001 risk assessment, from the certification body, explains that ISO/IEC 42001 clause 6.1.2 expects a documented process that assesses likelihood and impact and compares results against risk criteria. For agents that process personal data, the same scoring work feeds a GDPR Article 35 data protection impact assessment where processing is likely to be high risk.
Deliverable: a risk-scored register that ranks every agent and flags the highest-scoring agents for Step 3 tiering and Step 5 testing.
Step 3: Set autonomy tiers and human oversight gates
The autonomy policy sets agent behavior guardrails for each risk tier: what an agent may do alone, what needs approval and what it may never do.
Operators, not agents, decide when approval is required, and high-impact actions always wait for a human. The joint Five Eyes guidance states that approval decisions “should be determined by system designers or operators, not delegated to the agentic AI system.” Approval authority should also rise with the tier. The CSA’s autonomy-levels model shows one way to do this: Level 1 needs business owner approval, Level 2 manager and security sign-off, Level 3 a formal review board, and Level 4 executive authorization with documented risk acceptance.
Human-in-the-loop vs human-on-the-loop
Human-in-the-loop fits irreversible or high-consequence actions; human-on-the-loop fits lower-impact actions where monitoring and intervention are enough. Human-in-the-loop means a person approves an action before it runs. Human-on-the-loop means real-time monitoring with the ability to intervene, without blocking execution.
Approval thresholds by action impact can follow the joint guidance:
| Action impact | Example actions | Oversight model |
|---|---|---|
| Low, reversible | Read-only queries, drafting content | Autonomous with logging (human-on-the-loop) |
| Moderate | Updating non-critical records, internal messages | Sampled human review, human-on-the-loop monitoring, or independent authorization checks, depending on impact |
| High, hard to reverse | System resets, network egress, deleting critical records | Human approval before execution |
| Prohibited | Agent modifying its own privileges, deleting logs or audit records | Blocked; log deletion quarantined until a human approves |
Human approval has known failure modes. Anthropic reports that approval prompts in Claude Code lead to approval fatigue, where people stop paying attention to what they approve. Reserve human-in-the-loop for the actions that justify it, and show approvers the exact action, target and parameters.
Writing policies for non-human actors
An agent policy must state who the agent acts for, what it may touch and which actions need approval, in terms a control can evaluate at runtime. Write each rule with five elements:
- Actor: The agent identity and its human sponsor. A procurement agent acts for the buyer who launched it, never as a shared service account.
- Scope: Department, role and workforce type (human or agent) the rule applies to. A rule written for finance agents need not bind engineering’s coding agents.
- Resource: The tools, MCP servers and data classes in scope. Naming the approved MCP servers and tools keeps a newly added tool from inheriting access.
- Action: Allow, warn, require approval or block. Each verdict should be one a runtime control can apply without interpretation.
- Condition: The impact tier, data sensitivity or time window that triggers the action. A write to a customer record might run freely in a sandbox but require approval in production.
Follow NIST’s design tenets for agent identity: zero standing privilege, with access bounded to the minimum scope a designated task requires. The UK NCSC’s guidance on agentic AI risk adds that each policy should define when an agent must stop and seek approval, with approvals “both guaranteed and gated”.
Deliverable: an approved autonomy policy that maps each risk tier to permitted actions, approval thresholds and prohibited actions.
Step 4: Engineer guardrails and technical controls
A policy only holds if something stops a disallowed action before it runs, so security teams enforce the Step 3 policy inline, blocking or holding unauthorized actions before execution.
Guardrails split into two types. Deterministic guardrails, such as allowlists, permission checks and spend caps, give the same answer every time and should gate irreversible actions. Probabilistic guardrails, such as injection classifiers and intent models, catch attacks and misuse that fixed rules cannot express, but no classifier is perfect, so they work best alongside deterministic gates. OWASP’s Excessive Agency guidance says to implement authorization in downstream systems rather than relying on an LLM to decide whether an action is allowed.
Permission scoping, sandboxing and tool allowlists
Tool-call protection starts with least privilege: it limits what a hijacked agent can do, whatever the model’s output. Four controls carry most of the weight:
- Least privilege per tool: AWS recommends enforcing tool scoping at the gateway or protocol layer so agents can invoke only the tools their policy allows regardless of internal code. Because scoping is enforced outside the agent’s code, an injected instruction that changes the agent’s plan still cannot reach tools its policy does not allow.
- Approved MCP server lists: Google Cloud’s guidance for MCP states the agent “must not be able to dynamically register new tools or change the permissions of existing tools.” The OWASP GenAI Security Project’s Q3 2026 exploit roundup lists snapshotting MCP tool definitions at approval time, and requiring re-approval when they change, among potential defenses.
- Pre-execution blocking: Unapproved tool calls and actions above the agent’s permitted tier stop before they run. Blocking before execution means there is nothing to roll back.
- Sandboxing: Run code-execution and browsing tools in isolated environments with egress control. Google Cloud’s managed agent sandbox, for example, allows no external network access by default.
WitnessAI Agentic Control applies pre-execution blocking at the MCP layer: it enforces organization-wide approved lists of MCP servers and tools and blocks unauthorized tool calls before execution.
Enforcing policy by intent, not keywords
On their own, keyword rules cannot capture conversational context and intent: they flag legitimate work and miss violations phrased in ordinary language, so the Step 3 policy needs intent-based policy enforcement to work at runtime.
Intent-based policy enforcement evaluates who is acting, where the request is going, what the prompt contains and what the user or agent is trying to do. WitnessAI Control applies first-match, top-down intelligent policies on identity, destination, prompt content, detected intent and behavioral patterns, with allow, warn, block, route, coach and tokenize actions. Each Step 3 rule element maps to a runtime decision: actor to identity, resource to destination, condition to intent and data class, action to the policy verdict. The same policy can apply across chat applications, IDEs, native desktop AI tools, custom agents and MCP connections routed through the platform.
Bidirectional runtime inspection
Bidirectional runtime inspection examines outbound prompts and inbound responses, because agents can be attacked through either direction. Inbound tool responses and retrieved documents carry indirect injection; outbound prompts carry sensitive data and credentials. This layer detects direct and indirect prompt injection that redirects an agent’s goal, multi-turn jailbreaks that erode guardrails, credential exfiltration of keys, tokens or passwords through AI interactions, and sensitive data, using context-aware sensitive data detection by meaning rather than by pattern alone.
Witness Protect provides runtime defense for agents through bidirectional runtime inspection for prompt injection, jailbreaks, credential exfiltration, sensitive data and harmful responses. For sensitive data, WitnessAI’s NER-D model provides context-aware sensitive data detection through named-entity recognition, so it can recognize sensitive data that regex and keyword data loss prevention (DLP) rules alone can miss.
Where controls sit in your architecture
Each enforcement point sees a different slice of AI interactions, so the architect’s decision is about coverage, latency and failure behavior.
| Enforcement point | What it sees | Known blind spots |
|---|---|---|
| Network layer via proxy or Secure Service Edge (SSE) | All AI interactions crossing the network control point, regardless of app | Traffic that never crosses the control point, such as off-network devices |
| Endpoint or browser extension | Activity on managed devices or in the browser | Users who switch browsers, mobile apps, API traffic; extensions themselves can leak data |
| API or AI gateway | Model and MCP calls configured to use the gateway | Shadow AI in desktop apps and browsers that bypass it |
| In-application SDK | Calls inside instrumented applications | Every policy change becomes a refactoring project, as Forrester notes |
| MCP gateway | Tool eligibility and tool calls over MCP | Only traffic that uses MCP |
Three trade-offs need a written decision:
- Off-network coverage: Remote and unmanaged devices need a separate path. WitnessAI’s network-layer deployment integrates with existing proxy, firewall and SSE infrastructure, including Netskope SWG, Palo Alto Prisma Access, Zscaler Internet Access and F5 BIG-IP SSL Orchestrator, with no endpoint agents or browser extensions required for on-network deployment. Witness Anywhere extends coverage to off-network users through CrowdStrike endpoint detection and response (EDR), Jamf, Kandji or Active Directory.
- Latency: Inline checks add latency to every AI interaction. Architects should benchmark candidates on their own traffic before choosing an enforcement point.
- Fail-open versus fail-closed: Architects should fail closed for checks that prevent irreversible harm, such as PII sent to external providers or high-risk tool calls. For low-severity checks, they should fail open, log the skipped verdict and alert on the fail-open rate.
Write each of these decisions down before go-live, because each one sets what the controls do when something breaks.
Step 5: Test agents before deployment
Controls that look sound on paper can still fail under attack, so testing before go-live checks two things: that the guardrails hold, and that each agent’s risk score matches how it actually behaves. Single-turn tests miss attacks that unfold across many turns and tool calls, so the test plan has to cover those too.
Open-source harnesses such as NVIDIA garak now support multi-turn attacks, and MITRE ATLAS’s May 2026 update tags its techniques by platform, including agentic AI.
Use test results to recalibrate Step 2. An agent that a red team can push into an unapproved tool call has a higher effective risk than its register score suggests.
A NIST technical blog on AI agent hijacking evaluations states that “Evaluations need to be adaptive” because a new system may have weaknesses that earlier tests did not cover. Governance leads should require a retest after a model swap or version change, a new tool, MCP server or data access, a system prompt or orchestration change, or an incident closed in Step 7.
Witness Attack runs automated pre-production red teaming across multimodal and multi-step attack paths, including multi-step jailbreak simulation, so teams can confirm Step 4 controls hold before an agent goes live.
Deliverable: a test report with attack success rates per category, remediation status and a go-live sign-off from the accountable owner.
Step 6: Monitor, audit and attribute agent actions
Production monitoring complements inline controls. It shows what agents actually did, surfaces behavior that only becomes visible over time, and produces the evidence auditors ask for. The core output is human-to-agent attribution: a record connecting observed agent activity and tool invocations to the corporate identity that initiated the workflow. The depth of the audit trail depends on the integration and activity being captured. For supported AI coding tools, WitnessAI provides visibility into prompts, tool calls, tool responses and shell executions. Agentic Control also records blocked tool calls with the associated user, agent, tool and enforcement rule. That attribution gives regulators, incident responders and internal auditors a clear answer to “who told the agent to do that?” when someone says “the agent did it”.
Most organizations lack it today. A CSA study commissioned by Aembit found 68% of organizations cannot clearly distinguish AI agent actions from human activity. NIST’s March 2026 report, NIST AI 800-4: Challenges to the Monitoring of Deployed AI Systems, describes visibility into unanticipated agent activity as an emerging challenge, “particularly as the use of agent identifiers is not yet standardized or mature.”
Security and governance teams should build monitoring that covers six capabilities:
- Stateful audit trails: Immutable records of AI interactions per agent session, kept long enough for regulatory needs. EU AI Act Article 26(6) requires deployers of high-risk systems to keep logs under their control for at least six months.
- Reasoning traces: Execution chains show which input led to which tool call. Incident responders use them to find where an injection entered.
- Anomaly detection: Teams set baselines for tool call volume, destinations and data classes per agent. Security operations then alert on departures from those baselines, such as a new destination or a spike in calls.
- Permission scope drift: Teams compare the credentials and tools an agent uses against what its Step 3 tier permits. Drift sends the agent back to Step 2 for re-scoring or triggers credential revocation.
- Security information and event management (SIEM) export: CSA research finds that most enterprise SIEMs have not been updated to ingest MCP invocations, tool-call sequences and agent-to-agent traffic. Updating SIEM schemas therefore belongs in the monitoring plan.
- Spend telemetry: Token usage per agent feeds the FinOps lead’s KPI reporting. A sudden spike in token rate can also flag a runaway loop for the Step 7 playbook.
WitnessAI produces audit trails with human-to-agent attribution for agent actions captured through the platform and exports them to SIEM platforms.
Governance leads should route agents back to Step 2 for re-scoring on these lifecycle events: agent updates, new tools or MCP servers, model swaps, new data access and decommissioning. NIST AI RMF GOVERN 1.7 calls for processes “for decommissioning and phasing out AI systems safely,” which for agents means revoking credentials, removing tool access and closing the register entry.
Step 7: Respond to agent incidents and re-score
Containing an agent fast depends on having the kill switch built before the incident. Security and governance teams then restore a known-good state and apply what they learned to Steps 2, 3 and 4. Most organizations cannot yet say how fast they could stop an agent: in ISACA’s 2026 poll, 56% did not know how long it would take to halt an AI system during a security incident. NIST AI RMF MANAGE 2.4 expects mechanisms “to supersede, disengage, or deactivate AI systems that demonstrate performance or outcomes inconsistent with intended use,” with responsibilities assigned.
Three incident types need a prebuilt playbook:
| Trigger | Kill switch action | Rollback | Owner |
|---|---|---|---|
| Exceeded permissions (tool call or data access outside the permitted tier) | Block the agent identity; revoke its credentials; restrict permissions automatically, per the joint guidance’s trigger-action protocols | Reverse writes where possible; restore records from backup | CISO accountable; security operations responds |
| Runaway loop (repeated calls, token rate spike) | Enforce iteration cap and hard spend cap; terminate the session | Kill pending jobs; reconcile spend against budget | Platform owner; FinOps lead informed |
| Exfiltration (sensitive data or credentials in outbound traffic) | Block the destination and the agent; rotate exposed credentials | Notify affected parties; assess breach reporting duties | CISO accountable; governance lead for notification |
GDPR and the EU AI Act both set short reporting deadlines. Under GDPR Article 33, controllers must notify the supervisory authority without undue delay and, where feasible, within 72 hours of becoming aware of a personal data breach, unless it is unlikely to result in a risk to individuals.
EU AI Act Article 73 requires providers to report serious incidents involving high-risk systems immediately after establishing a causal link or its reasonable likelihood, and no later than 15 days after awareness. The maximum is two days for widespread infringement and ten days for a death; a deployer that identifies a serious incident must inform the provider and suspend use of the system.
Close the loop with four actions after each incident:
- Run a post-incident review that traces the incident through the human-to-agent attribution record.
- Update the risk register with the root cause and the control that failed.
- Re-score the agent in Step 2.
- Adjust the Step 3 policy and the Step 4 controls, then retest in Step 5.
Security and governance leads should be able to show three things after each incident: an updated register entry, a re-scored agent, and an adjusted policy and control set.
Mapping the framework to NIST AI RMF, ISO/IEC 42001 and the EU AI Act
The seven steps produce the evidence that three frameworks ask for, so one program can serve all of them. Treat each row as a reference, not a legal determination. ISO/IEC 42001 clause and Annex A numbering differs across certification body sources, and EU AI Act deployer duties apply only to high-risk systems on the dates shown, so verify current requirements against the official texts before relying on any row.
| Step | Control | NIST AI RMF | ISO/IEC 42001 | EU AI Act |
|---|---|---|---|---|
| 1. Inventory | Agent register | GOVERN 1.6; MAP 1.1; MAP 4.1 | Clause 4.3 scope | Article 4 AI literacy (applies since 2 February 2025) |
| 2. Classify and score | Risk-scored register | GOVERN 1.3; MEASURE 1.1 | Clauses 6.1.2 and 6.1.4; A.5 impact assessment | Article 27 fundamental rights impact assessment for specified deployers |
| 3. Autonomy policy | Tiers and approval gates | GOVERN 1.4; MANAGE 1.3 | Clause 5.3; A.3.2 roles and accountability | Article 14 human oversight; Article 26(2) assign competent overseers |
| 4. Guardrails | Inline enforcement | MEASURE 2.7; MANAGE 1.3 | Clause 8 operation; A.6.2.6 | Article 14(3) oversight measures built in or identified for deployers |
| 5. Test | Red team and go-live sign-off | MEASURE 2.3, 2.5, 2.6; MANAGE 1.1 | A.6.2.4 verification and validation; A.6.2.5 deployment | Provider requirements under Chapter III; deployers follow instructions for use |
| 6. Monitor and attribute | Audit trail and SIEM export | MEASURE 2.4; MANAGE 3.1, 4.1 | Clause 9.1; A.6.2.8 event logs | Article 12 logging; Article 26(6) six-month log retention |
| 7. Respond and re-score | Kill switch and playbook | MANAGE 2.4, 4.1; GOVERN 1.7 | Clause 10.2 corrective action; A.8.4 communication of incidents | Article 73 serious incident reporting |
EU AI Act timing changed in 2026. Regulation (EU) 2026/1744, the Digital Omnibus on AI, entered into force on 27 July 2026 and moved high-risk obligations for Annex III systems to 2 December 2027 and for Annex I product systems to 2 August 2028. Article 50 transparency obligations have applied since 2 August 2026.
Two further regimes apply to many agent deployments:
- GDPR: Article 22 restricts decisions based solely on automated processing with legal or similarly significant effects, and Article 35 requires a data protection impact assessment for likely high-risk processing. Spain’s data protection authority notes that agentic AI “will not always involve automated decisions within the meaning of Article 22,” so the test should be documented per agent.
- PCI DSS 4.0.1: Requirements 7, 8 and 10 govern access, authentication and logging for accounts that touch the cardholder data environment. The PCI Security Standards Council states that incident response plans under Requirement 12.10 should consider the potential for an AI with agency to become a “malicious insider,” and recommends payment tokens or single-use primary account numbers (PANs) to limit an agent’s scope.
WitnessAI is SOC 2 Type II certified and supports PCI DSS 4.0.1-related governance requirements. It helps teams produce the evidence these frameworks ask for, but using it does not by itself make an organization compliant.
Measuring agentic AI risk: KPIs and financial impact
Board reporting needs a small set of KPIs that show exposure, control effectiveness and cost, drawn from Step 6 telemetry but summarized for executives. Use your first quarter of data to set baselines for agent-specific KPIs such as blocked action rate and mean time to respond (MTTR) to AI incidents.
| KPI | Definition | Primary audience |
|---|---|---|
| Inventory coverage | Agents in the register divided by agents discovered | CISO, governance lead |
| Attribution coverage | Agent actions with a human-to-agent attribution record | Governance lead, auditors |
| Approval rate | Approved high-impact actions divided by requested; a near-100% rate suggests approval fatigue | Governance lead |
| Blocked actions | Pre-execution blocks by category and agent tier | CISO, architect |
| MTTR for agent incidents | Detection to containment, by playbook type | CISO |
| Permission scope drift | Agents using tools or credentials outside their permitted tier | CISO, architect |
| Token spend per successful outcome | Total cost of runs divided by runs meeting the quality bar | FinOps lead |
| Cost avoidance | Dollar value of incidents prevented and non-value spend blocked | CISO, FinOps lead |
Two measures put AI costs in context:
- Cost per successful outcome: The FinOps Foundation defines this as total cost of all runs divided by runs that meet the quality bar, for example $1,200 / 8,000 = $0.15. Tracking it per agent shows which agents cost more than the work they complete.
- AI spend management: The FinOps Foundation’s State of FinOps 2026 survey, released in February 2026, drew 1,192 respondents and found 98% now manage AI spend, up from 31% two years earlier. For an agent program, the FinOps lead can feed per-agent token telemetry from Step 6 into existing AI spend reporting, so agent costs are reported alongside other AI spend.
For the board, frame these KPIs against the cost of failure. Gartner predicts that over 40% of agentic AI projects will be canceled by the end of 2027 because of escalating costs, unclear business value or inadequate risk controls, so a program that reports cost per outcome alongside control effectiveness speaks to all three cancellation reasons.
WitnessAI’s AI FinOps dashboard tracks spend and token usage, analyzes business intent, supports lower-cost model routing and translates prevented incidents into cost-avoidance figures.
Getting started: a 30-60-90 day rollout
A 90-day rollout can establish ownership and visibility first, then enforcement, then monitoring and reporting.
| Phase | Work | Exit criteria |
|---|---|---|
| Days 1–30 | Name owners and the AI risk committee; complete Steps 1 and 2 | Approved RACI; risk-scored register for all discovered agents |
| Days 31–60 | Complete Steps 3, 4 and 5 for the highest-scoring agents | Approved autonomy policy; inline controls live; go-live sign-offs |
| Days 61–90 | Complete Steps 6 and 7; start KPI reporting | SIEM integration; tested kill switch; first board KPI report |
WitnessAI maps onto this sequence as the confidence layer for enterprise AI, complementing existing SSE, proxy, firewall, SIEM and EDR tooling rather than replacing it, with visibility and intent-based controls for the human and digital workforce, and runtime security for the models, applications and agents they depend on. Each WitnessAI capability supports specific steps:
- Observe: Its inventory of AI applications, agentic activity and MCP servers observed through the platform, classified by risk and intent, feeds the Step 1 agent register. It also keeps a record of AI interactions, which feeds Step 6 audit trails and Step 7 post-incident review.
- Control: Enforces the Step 3 policy at runtime through intent-based policy enforcement. Its allow, warn, block, route, coach and tokenize actions apply the verdicts in the approved Step 3 autonomy policy.
- Protect: Witness Protect provides the Step 4 bidirectional runtime inspection layer. It inspects outbound prompts and inbound responses for prompt injection, credential exfiltration and sensitive data.
- Attack: Witness Attack supports Step 5 pre-deployment red teaming. Its results feed the Step 5 test report and go-live sign-off.
- Agentic Control: Applies Step 4 pre-execution blocking for MCP tools and produces the Step 6 human-to-agent attribution record. It enforces organization-wide approved MCP server and tool lists, and its attribution record supports Step 7 post-incident review.
Teams that already run a proxy or SSE can reach coverage quickly. In one WitnessAI customer case study, a Tier-1 global telecom became production-ready for more than 150,000 employees in under 10 days using existing network infrastructure with no endpoint changes. Each customer runs on a single-tenant cloud instance with customer-controlled encryption keys and multi-region data residency support.
Putting the framework to work
For CISOs, the measure of this framework is whether you can show the board which agents exist, what each is permitted to do, what was blocked and who answers for each action. Teams that can produce that evidence can expand agent use with confidence instead of pausing it. Governance leads should own the autonomy policy and audit evidence, architects should own the enforcement points and their coverage limits, and FinOps leads should own cost per outcome. To evaluate how WitnessAI supports discovery, runtime enforcement, MCP governance and AI spend visibility in your environment, request a WitnessAI demo.