What breaks when security teams treat untrusted input and sensitive data as separate risk categories in agentic systems?

Why This Matters for Security Teams

Agentic systems collapse the old separation between data security and input security because the same payload can both steer model behaviour and unlock downstream action. When a retrieval result, ticket, email, or document is treated as trustworthy content, the agent may use it as evidence, then act on it with the privileges attached to its workload identity. That makes untrusted input a delivery mechanism for sensitive-data exposure, not a separate category of risk.

This is why guidance from the OWASP Agentic AI Top 10 and the NIST AI Risk Management Framework increasingly treats prompt injection, data poisoning, and excessive tool authority as linked problems rather than isolated ones. NHIMG research shows the same pattern in live incidents: the Gemini AI Breach demonstrates how ordinary content can become an execution path, while the OWASP NHI Top 10 shows why identity and content abuse now converge in agentic workflows. In practice, many security teams discover that boundary only after the agent has already read, reasoned over, and acted on compromised context.

How It Works in Practice

In retrieval-augmented and context-driven systems, the agent does not experience a clean boundary between “input” and “sensitive data.” A poisoned document may be fetched because it appears relevant, then parsed by the model, then copied into a tool call, API request, or generated response. Once that happens, the payload has crossed from content into action. The right control objective is therefore not just content filtering, but runtime authority management.

Current best practice is evolving toward layered controls:

• Use trust-tiered retrieval so the agent knows which sources are advisory and which are operational.
• Apply runtime policy checks before tool use, not only before ingestion.
• Issue short-lived credentials for a single task, then revoke them automatically when the task ends.
• Bind actions to workload identity so the system can prove what the agent is, not just what token it holds.
• Log the source, rationale, and downstream action together so poisoned context can be traced after the fact.

That approach aligns with the CSA MAESTRO agentic AI threat modeling framework and the NIST AI Risk Management Framework, both of which emphasize runtime governance over static assumptions. It also matches the operational lessons in NHIMG coverage such as LLMjacking: How Attackers Hijack AI Using Compromised NHIs, where exposed credentials and AI misuse combine into a single attack chain. Where available, teams should complement policy-as-code with workload identity systems such as SPIFFE and OIDC-backed ephemeral credentials. These controls tend to break down in loosely governed multi-agent chains because one agent’s “trusted” output becomes the next agent’s unreviewed instruction.

Common Variations and Edge Cases

Tighter context controls often increase integration overhead, requiring organisations to balance security against latency, developer friction, and retrieval quality. That tradeoff is real, especially when teams want strong filtering without breaking the usefulness of enterprise search or agent memory.

One common edge case is internal content that is still untrusted. A document stored in a corporate repository may be authentic but still malicious if an attacker has poisoned it upstream. Another is mixed-trust retrieval, where a single prompt contains both approved policy text and user-supplied attachments; current guidance suggests treating the entire assembled context at the lowest trust level unless provenance is explicit. There is no universal standard for this yet, which is why organizations should document their own trust labels and enforcement rules.

Teams also need to watch for overconfidence in static roles. A role may be correct for the human owner of the agent, but it is often too coarse for the agent’s moment-to-moment actions. That is why the NIST Cybersecurity Framework 2.0 and MITRE ATLAS adversarial AI threat matrix are useful complements: they force teams to think in terms of adversary behaviour, not just data classification. The Analysis of Claude Code Security is a useful reminder that once agent output can trigger code, data, or credential operations, trust boundaries must be enforced at execution time, not only at ingest.

Related resources from NHI Mgmt Group

• How can security teams prioritise sensitive data risk across file systems and SharePoint Online?
• How should security teams govern agentic systems that access sensitive data?
• How should security teams govern access when sensitive data is spread across multiple systems?
• How should security teams use sensitive data discovery to reduce AI risk?