How does your AI governance program compare?

    See where your program has gaps in less than 2 minutes.

    Take the assessment
    Implementation Guide

    How to Write an AI Agent Threat Model in One Day

    A practical, time-boxed methodology for building an AI agent threat model before production rollout: assets and scope, trust boundaries, STRIDE-adapted enumeration, and prioritized runtime mitigations.

    In brief: A credible AI agent threat model can be produced in one day by time-boxing four phases: defining assets and scope; mapping trust boundaries across tools, memory, and identity; enumerating agent-specific risks using a STRIDE-adapted checklist informed by OWASP and MITRE ATLAS; and prioritizing runtime mitigations such as least privilege and policy enforcement. This condensed approach does not replace ongoing governance, but it produces an actionable baseline before production rollout.

    The one-day threat modeling cycle

    Treat the day as four focused phases. Adjust phase lengths to agent complexity and the number of tool integrations in scope.

    1. Scope and assets

      Identify the agent, its tools, memory stores, and identities in scope.

    2. Trust boundaries

      Map every agent-to-tool, agent-to-model, and agent-to-agent interface.

    3. Threat enumeration

      Apply STRIDE, adapted for agent-specific risks, to each component.

    4. Mitigation priority

      Rank runtime controls by impact and feasibility before sign-off.

    Why AI agents require a distinct threat model

    AI agents extend the attack surface of a traditional application. A single user input can trigger a multi-step tool-call chain that reaches several downstream systems without human review in between. Persistent memory adds a data store that can be poisoned or exfiltrated across sessions, unlike stateless application state. Agents also act under delegated or impersonated identity, raising spoofing and authorization questions that do not exist in conventional service-to-service architectures.

    OWASP's Top 10 for LLM Applications formalizes some of this as a distinct risk category, Excessive Agency, describing harm caused by agents granted more functionality, permissions, or autonomy than their task requires, alongside Prompt Injection as a primary risk. MITRE ATLAS catalogs adversary techniques observed against AI systems in a structure modeled on ATT&CK, and NIST's AI Risk Management Framework organizes risk management into Govern, Map, Measure, and Manage functions.

    No single authoritative standard yet exists specifically for AI agent threat modeling. Current practice adapts these general AI and LLM frameworks to agentic systems, which is the approach this guide follows.

    Mapping agent-specific trust boundaries

    Treat the agent as a set of distinct components rather than a single monolithic system. Trust boundaries exist between the agent and each tool it can invoke, between the agent and the underlying model, between cooperating agents, and between the agent and its memory stores.

    Short-term context and long-term or persistent memory should be treated as separate assets, each requiring its own data classification, since a compromised memory store can influence agent behavior across unrelated sessions. Standards work on tool-integration protocols, including Anthropic's Model Context Protocol, formalizes this by documenting that tool servers and hosts operate across explicit trust boundaries requiring authorization and consent before an agent can invoke a tool or access a resource. Using this kind of reference model helps a security team map data flows quickly rather than debating boundary definitions during the exercise itself.

    Agent-specific risk categories to enumerate (STRIDE-adapted)

    Walk each in-scope component and boundary against this checklist. Capture concrete attack paths, not generic labels.

    • Spoofing: identity spoofing of the user, the agent, or a downstream service in a delegated identity chain.
    • Tampering: poisoning of persistent memory or manipulation of tool outputs that feed subsequent decisions.
    • Repudiation: absence of audit logging for tool invocations, preventing reconstruction of a multi-step action chain.
    • Information Disclosure: exfiltration of memory contents or context data through a compromised tool call.
    • Denial of Service: resource exhaustion caused by unintended or chained tool calls triggered by a single input.
    • Elevation of Privilege: excessive agency, where the agent holds more permissions or autonomy than its task requires.

    Runtime mitigations to capture

    As you close enumeration, prioritize controls you can enforce in production: least privilege on tools and identities, policy enforcement on agent actions, and audit logging sufficient to reconstruct multi-step chains. A threat model that stops at risks without ranked mitigations is incomplete for rollout decisions.

    Assigning ownership and feeding ongoing governance

    A one-day threat model is a starting point, not a final artifact. NIST's AI RMF Govern function calls for assigning accountability for AI risk decisions, and that accountability should be reflected in who signs off on the exercise output. Joint guidance from NSA, CISA, and international partners on deploying AI systems securely recommends continuous monitoring throughout the AI system lifecycle, which means the mitigations identified during the exercise should be tracked into an operational governance process rather than left as a static document.

    Agent-specific risks such as excessive agency should be entered into the same risk register used for traditional application vulnerabilities, with the same review cadence. Time allocations described here are a practitioner methodology, not a codified standard, and teams should adjust phase lengths based on the complexity of the agent and the number of tool integrations in scope.

    Common questions

    Does a one-day threat model replace a full security review?

    No. It produces a time-boxed baseline covering the highest-impact agent-specific risks before rollout. Complex or high-risk agents may still require deeper follow-up analysis after initial deployment.

    How often should the exercise be repeated?

    Whenever the agent's tool set, permissions, or memory architecture changes materially, since new integrations introduce new trust boundaries that were not covered in the original exercise.

    Can this methodology be used for multi-agent systems?

    Yes, but agent-to-agent trust boundaries should be mapped individually rather than treating cooperating agents as a single unit, since each delegation of identity or permission introduces a separate spoofing and privilege-escalation surface.

    Turn a one-day threat model into enforceable runtime controls

    A threat model identifies where least privilege, policy enforcement, and audit logging are needed. Runtime governance is what makes those mitigations enforceable in production.

    Explore Runtime Governance