Enterprise AI Security: Governance, Controls, and Monitoring
Enterprise AI security requires source-code visibility, evidence-backed control mapping, least privilege, and tested containment. A practical CISO guide.
By Jonny Freedman, CEO, Agntz
By Jonny Freedman · Published
Enterprise AI Security often fails first at visibility, not at policy. Governance written on paper cannot cover hidden models, unregistered agents, or shadow tools that security teams have not mapped. A defensible program therefore starts with evidence about what exists, what it can reach, and which controls apply.

Table of Contents
- The Visibility Gap Undermining Enterprise AI Security
- Building an AI Bill of Materials from Source Code
- Prompt Injection and Indirect Prompt Injection as Control Failures
- Mapping AI Capabilities to ISO and NIST Controls
- Procurement Security Checks for AI Agents
- Proving Containment and Blast Radius Before Incidents
- Frequently Asked Questions
The Visibility Gap Undermining Enterprise AI Security
Policy design is usually the easiest part of an AI program. Inventory is the part that breaks. When teams can't answer what models, agents, connectors, and tools are in use, every downstream control becomes partial by definition.
The operational pattern is familiar: governance is often written ahead of discovery, not after it. That matters because shadow AI doesn't wait for approval, and unregistered agents don't inherit the safeguards written for approved systems. They create blast radius before anyone has labeled the asset.
Practical rule: if the inventory is incomplete, the control set is incomplete.
Why policy fails when visibility is weak
Traditional security tooling tends to see network flows, endpoints, or packaged software. AI systems often sit across code, data, prompts, plugins, and external services. That means the useful question isn't whether a policy exists. It's whether the organization can prove which AI capabilities the policy covers.
The mismatch shows up in agent identities, tool bindings, and hidden data paths. If a team doesn't know a model is present, it can't map that model to access rules, logging requirements, or escalation paths. If it doesn't know a connector exists, it can't judge where data can leave the environment. Written governance can look mature while operating blind.
What good visibility has to include
A useful inventory has to be more than a list of approved vendors. It should surface embedded models, detected vendor references, indirect package calls, and the dependency evidence that shapes effective reach. Current Agntz evidence does not support presenting this as a complete resolved transitive-dependency graph.
For teams trying to close that gap without adding another manual review queue, Agntz's source-code inventory workflow is one example of an inside-out approach that reads code to expose capability, reach, and control gaps before runtime. That matters because the evidence needs to come from the system itself, not just from vendor claims or architecture diagrams. An early control in enterprise AI security is a well-evidenced map of what the repository reveals.
Building an AI Bill of Materials from Source Code

Source code gives security teams something runtime monitoring can't. It shows intent, wiring, and dependency paths before the application starts moving data. That's why an AI Bill of Materials built from source is more useful than a package list pulled from a scanner that only understands declared dependencies.
Agntz public copy says more than 10,000 open-source agent repositories have been scanned and classified. That figure does not establish that most repositories share a particular flaw. The implementation-backed point is narrower: source analysis can expose model loaders, tool bindings, vendor references, and outward data paths that a package-name inventory alone may not explain.
What the source-level map needs to show
A useful AIBOM is not just a component catalog. It should identify the model, the tools, the data paths, the external services, and the autonomy loops that make an agent act. It should also show where a capability gets its inputs and where it can send outputs. That is how a security team separates a summarizer from a system that can read, decide, and act.
The capability map matters because it translates code into operational reach. A connector that can read tickets, write to Slack, and call a billing API is not “just another integration.” It is a set of permissions with distinct blast radius. Source-level analysis can expose those bindings before deployment and give reviewers evidence tied to the implementation.
Code-level provenance beats runtime guesswork when auditors ask for evidence.
Why runtime observation falls short
Outside-in monitoring sees what an agent did after it has already loaded, interpreted, and acted. It may show an API call or a prompt exchange. It may not show the package or vendor relationship that introduced the behavior, the embedded model that changed the trust boundary, or the indirect package call that bypassed an expected scanner.
That's the practical difference between visibility and proof. A code-level report can attach file, line, and call-path references, so a reviewer can trace a capability back to the exact source. That kind of evidence supports governance decisions, procurement review, and audit response in a way runtime logs rarely do.
For teams needing a quick exposure estimate before a deeper review, Agntz's risk calculator can be used as a secondary triage step after source analysis. It doesn't replace inventory. It helps prioritize what needs closer scrutiny first.
Here's the implementation sequence that tends to work best.
- Ingest the repository. Start with source, not with the vendor brochure.
- Review dependency evidence. Include declared packages, any available indirect or transitive signals, and embedded models; corroborate unresolved edges with package-manager and build records.
- Map capabilities. Tie tools, permissions, data paths, and autonomy loops to code.
- Score reach. Show which assets each capability can touch and how far it can go.
Prompt Injection and Indirect Prompt Injection as Control Failures

Prompt injection gets misunderstood when it's treated like bad text filtering. The core problem is control-plane manipulation. OWASP's Large Language Model guidance treats prompt injection as a top risk because crafted inputs can lead to unauthorized access, data breaches, and compromised decision-making (OWASP's LLM Top 10 summary). NIST's taxonomy defines direct prompt injection as attacker-entered text meant to alter an LLM's behavior so the user can perform unintended or unauthorized actions (NIST AI taxonomy and RMF context).
Direct and indirect attacks work differently
ACL's findings separate the mechanics clearly. Direct prompt injection is malicious user input aimed at goal hijacking or prompt leaking. Indirect prompt injection is malicious content embedded in external sources an LLM retrieves, with the goal of diverting benign user instructions (ACL findings on indirect prompt injection). That distinction matters because retrieval-augmented systems and agents don't just read text. They act on it.
A tool-augmented agent that fetches web pages, files, or tickets needs strict trust boundaries. If the system blends instructions with retrieved content, a poisoned source can alter behavior without touching the user prompt at all. That's why prompt injection becomes a control problem as soon as the application can access tools, memory, or external systems.
Why indirect injection is an enterprise issue
An empirical study analyzed 1.2 billion URLs from 24.8 million hosts and validated 15.3 thousand indirect prompt injection instances across 11.7 thousand pages (the empirical study). That's not an edge case. It shows untrusted web content can carry embedded instructions at internet scale.
The governance response has to match the mechanics. Separate system instructions from user input. Constrain tool permissions. Treat retrieved content as untrusted until it is validated. If a capability map shows that a model can fetch outside content and then call a tool, that path deserves much tighter review than a passive summarizer.
Mapping AI Capabilities to ISO and NIST Controls
Frameworks help when they create common language. They don't help when they stop at vocabulary. NIST's guidance for generative AI says legal and regulatory requirements involving AI must be understood, managed, and documented, and that the risk management process and its outcomes must be established through transparent policies, procedures, and other controls based on organizational risk priorities (NIST AI RMF guidance). That is a control expectation, not a slide deck.
The useful move is to map each AI capability to a named control and attach evidence that an auditor can verify without trusting the vendor. That evidence should point back to code, not just architecture.
Control mapping examples that hold up in review
| Capability | NIST AI RMF Control | ISO 42001 Control | Evidence Type |
|---|---|---|---|
| Tool calling | Document and manage operational risk | Operational controls for AI use | File, line, call path |
| External data retrieval | Understand and control input sources | Data governance and monitoring | Source reference plus dependency chain |
| Agent autonomy loop | Establish and document risk management outcomes | AI system lifecycle controls | Capability map and blast-radius score |
| Sensitive data access | Manage and document legal and regulatory requirements | Access and information protection controls | Access path evidence and policy reference |
The point of the table is not to turn governance into paperwork. It is to shorten decision latency. When GRC teams see a capability tied to a named control and supported by source-level evidence, they can approve, restrict, or decline faster because the discussion is concrete.
Where named controls beat abstract frameworks
Named controls reduce ambiguity. A finding tied to a broad framework label can spark a debate about interpretation. A finding tied to a specific control, with file and call-path evidence, narrows the issue to whether the implementation satisfies the requirement.
That approach can also help regulated organizations assemble evidence for more than one review program. Applicability still depends on the organization's systems, obligations, and auditor interpretation; code-level evidence supports a control assessment but does not itself prove compliance.
Procurement Security Checks for AI Agents

Procurement teams usually ask whether an agent solves the business problem. Security teams need the harder answers, what it can reach, what it depends on, and what it can do if it is compromised. Procurement starts with evidence, not assurances, because source-level provenance is what turns a vendor claim into something you can audit.
MITRE ATLAS documents 19 new techniques spanning GenAI attacks such as RAG poisoning, false RAG entry injection, LLM prompt crafting, prompt obfuscation, and discovery of LLM system information, plus supply-chain vectors such as compromising model and container infrastructure (MITRE ATLAS overview). That taxonomy helps in vendor review because it forces teams to ask whether the agent is exposed to retrieval poisoning, tool misuse, or supply-chain tampering. It also lines up with the risks called out in our AI agent security risks review, where hidden dependencies and indirect control paths create gaps that runtime monitoring alone misses.
A procurement checklist that works in practice
- Review the AIBOM. Confirm declared packages, available indirect or transitive signals, embedded models, and indirect package calls; validate unresolved dependency edges separately.
- Correlate known weaknesses. Check dependencies against current vulnerability data and map the result to the attack patterns in ATLAS.
- Audit data flow. Identify where data enters, where it gets stored, and where it can leave the environment.
- Test runtime controls. Validate whether the agent's permissions, approvals, and isolation behave as claimed in a staging environment.
Shadow vendor detection belongs in the same review. If the agent uses a hidden model, an unlisted SaaS service, or a transitive dependency that changes data egress behavior, procurement should treat that as a material finding. The vendor answer needs to be concrete enough to support a go, no-go, or constrained deployment decision.
Agntz is one tool that can support that evaluation by reading source code to produce capability maps, AIBOMs, blast-radius scoring, and control-level evidence before runtime. That does not replace procurement judgment. It gives it evidence.
A vendor that cannot explain transitive dependencies and data egress paths does not have a complete security story.
Proving Containment and Blast Radius Before Incidents
Visibility without containment is just better observation. Enterprises can monitor AI behavior and still be unable to stop it. A governed deployment therefore needs least-privilege permissions, purpose limits, a tested termination path, and network isolation appropriate to the agent's effective reach.
Blast radius needs to be calculated before rollout
A blast-radius score is only meaningful if it reflects what an agent can reach. That means scoring per capability and per asset, not just per service. A read-only summarizer and a workflow agent with tool access can't share the same containment assumptions.
The practical question is whether the organization can prove that a misbehaving agent won't cross a boundary. If an agent can touch sensitive systems, send data outward, or invoke actions on behalf of a user, the containment plan needs to be explicit. Agntz's implemented cadence checks active repositories daily, scans changed source, and may reuse unchanged results. Organizations that require per-commit enforcement should add it in their own CI/CD controls.
What containment proof looks like
Containment proof starts with least privilege, but it doesn't end there. Teams need to know whether they can enforce purpose limits, kill an agent quickly, and isolate it from protected networks if behavior changes. Those are operational controls, not policy statements.
A good report should show the agent's inputs, outputs, tool calls, and effective reach. It should also show what changes since the last scan altered the blast radius. That gives incident response something it can act on, and it gives auditors evidence that governance is active rather than static.
If the agent can't be contained, the deployment isn't governed. It's only observed.
Frequently Asked Questions
How do enterprises inventory hidden AI models and agents?
They need source-level discovery, not just vendor registers. Inventory should include declared packages, available indirect or transitive dependency signals, embedded models, tool bindings, and external services; unresolved dependency edges should be validated with build and package-management evidence. Runtime logs can confirm activity, but they usually can't prove what exists in the codebase before launch.
What is the difference between direct and indirect prompt injection?
Direct prompt injection comes from attacker-controlled user input. Indirect prompt injection lives inside retrieved content such as web pages or files, then changes model behavior when the system reads it. The second form is especially dangerous in agents that fetch outside content and can act on it.
How do auditors verify AI governance controls?
They verify evidence tied to named controls, not just policy language. File, line, and call-path references are stronger than architecture diagrams because they show exactly where a capability exists and how it reaches data or tools. That makes review faster and more defensible.
What should security teams check before approving an AI agent?
They should review the AIBOM, trace data flows, correlate known weakness patterns, and test runtime permissions in staging. They should also ask about transitive dependencies, embedded models, and any external services that can change data egress behavior or expand the agent's reach.
Why is blast radius more important than monitoring?
Monitoring tells teams what happened. Blast-radius analysis tells them what could happen and what must be contained before deployment. If an organization can't isolate, terminate, or limit an agent's purpose, observation alone won't prevent damage.
Agntz reads source code to produce an AI Bill of Materials, capability maps, blast-radius scoring, and control-level evidence before runtime. That gives CISOs and AppSec teams a way to govern agents from the inside out, instead of trying to infer exposure from runtime noise. Visit Agntz to request a free first scan and use the risk calculator as a secondary way to triage exposure before deeper review.
Own your AI risk
Estimate your exposure in under 3 minutes. No install, no access to grant.
Estimate Your Exposure