A runtime security pattern that watches workload behavior, builds a baseline, and then generates enforceable controls from that evidence. It is most relevant where workloads or AI agents behave differently over time and need a live boundary rather than a static assumption.
Expanded Definition
Observe-and-Generate is a runtime security pattern that treats observed behavior as the source of truth for policy creation. Rather than assuming a workload, service, or AI agent should have a fixed permission set, the pattern watches requests, tool use, identity context, data flows, and error conditions, then generates controls that reflect actual behavior. In practice, it sits between discovery and enforcement: first observe, then translate evidence into boundaries such as allowlists, session limits, token restrictions, or step-up checks. That makes it especially relevant in environments where software changes quickly, where agent actions are non-deterministic, or where non-human identities accumulate permissions faster than teams can review them.
The concept aligns closely with the governance intent of the NIST Cybersecurity Framework 2.0, especially where asset understanding, risk response, and continuous improvement depend on current evidence rather than stale assumptions. Definitions vary across vendors because some products use the phrase for policy synthesis, while others use it for runtime detection with automated hardening. At NHIMG, the clearer interpretation is a feedback loop that turns observed behavior into enforceable security intent. The most common misapplication is treating a one-time observation as a stable policy source, which occurs when teams generate controls from a short learning window and never revalidate them as workloads or agents change.
Examples and Use Cases
Implementing Observe-and-Generate rigorously often introduces policy churn, requiring organisations to weigh tighter runtime control against the operational cost of rebaselining when behavior changes.
- An AI agent is observed calling internal tools, and the system generates a narrower execution policy that restricts the agent to approved endpoints and approved tool scopes.
- A cloud workload is monitored during normal operations, and the resulting evidence is used to create network and identity controls that block unexpected east-west connections.
- A non-human identity used for automation is found to request broad token access, and the generated control reduces standing permissions to the minimum required for observed tasks.
- A microservice begins interacting with a new data store after a code change, and the security team uses the observed path to produce an updated boundary and alert rule.
- For guidance on how evidence-driven security fits into broader governance, teams often compare the pattern with the risk-driven control logic described in NIST Cybersecurity Framework 2.0, even though no single standard formally names Observe-and-Generate.
Why It Matters for Security Teams
Observe-and-Generate matters because static security assumptions fail quickly in systems that self-modify, auto-scale, or delegate actions to agents. When the pattern is applied well, it reduces over-permissioning, shortens the time between behavior change and control update, and makes policy reflect actual runtime risk. That is particularly important for NHI governance, where service accounts, tokens, and agent identities can be created faster than manual reviews can keep up. It also helps security teams move from theoretical least privilege to evidence-based least privilege, which is more defensible when incidents, audits, or access disputes arise.
The pattern also changes how teams think about trust boundaries. Instead of assuming the boundary is fixed at deployment time, practitioners continuously derive it from observed actions, identity signals, and context. This makes it useful for AI systems whose action space expands through tool access, retrieval, or orchestration layers. Organisations typically encounter the limits of static controls only after a workload reaches a sensitive system or an agent oversteps its intended scope, at which point Observe-and-Generate becomes operationally unavoidable to address.
Standards & Framework Alignment
This section maps relevant standards and security frameworks to the operational risks and controls described in this guidance.
OWASP Non-Human Identity Top 10 and OWASP Agentic AI Top 10 address the attack and risk surface, while NIST CSF 2.0, NIST AI RMF and NIST SP 800-63 set the governance and control requirements practitioners need to meet.
| Framework | Control / Reference | Relevance |
|---|---|---|
| NIST CSF 2.0 | GV.RM-01 | Risk management drives evidence-based control decisions for dynamic systems like this pattern. |
| NIST AI RMF | The AI RMF centers on govern and map functions that rely on ongoing system understanding. | |
| OWASP Non-Human Identity Top 10 | NHI guidance emphasizes runtime control of non-human identities and their permissions. | |
| OWASP Agentic AI Top 10 | Agentic AI security focuses on constraining tool use and action scope from observed behavior. | |
| NIST SP 800-63 | IAL2 | Digital identity assurance supports stronger confidence in identity context used to generate controls. |
Derive agent guardrails from actual tool calls, then enforce and monitor those limits continuously.
Related resources from NHI Mgmt Group
- Why do attackers often check model availability before trying to generate content?
- How should teams decide whether to let AI generate remediation policies?
- How should security teams govern AI services that can generate offensive content?
- Should organisations allow AI tools that can generate attack code?
Deepen Your Knowledge
Reviewed and updated by the NHIMG editorial team on August 18, 2026.
NHI Mgmt Group — the #1 independent authority on Non-Human Identity, IAM, and Agentic AI security. nhimg.org
