Artificial intelligence (AI) agents are moving quickly from experiments to real business environments. They are no longer just answering questions. They are beginning to access systems, retrieve information, use tools, and take actions on behalf of users. That shift creates a security challenge that most organizations have not fully reckoned with yet.
A recent vulnerability involving NVIDIA’s NemoClaw and the OpenClaw AI agent framework is a useful example of what that challenge actually looks like in practice. The issue was not simply a vulnerable AI model. It was the infrastructure surrounding the model. That distinction matters for anyone responsible for keeping a business secure.
The Story in Plain English
Researchers from Cyera’s Oasis Identity Research discovered a networking configuration flaw involving NemoClaw, NVIDIA’s tool for deploying the OpenClaw AI agent framework inside OpenShell sandboxes. At the center of the issue was Ollama, an open source runtime commonly used to run AI models locally.
NemoClaw configured Ollama in a way that made its application programming interface (API) reachable beyond the local machine. That API also did not require authentication. Together, those two facts created an opening for an attacker.
The researchers demonstrated that a malicious webpage could use a technique called DNS rebinding to reach the local Ollama server from outside. Once that access was established, an attacker could interact directly with the model server: enumerating available models, running inference, modifying or deleting models, and manipulating the model’s chat template.
That last part is the one worth sitting with. The chat template helps determine how an AI agent’s instructions are processed. Manipulating it could let an attacker plant hidden instructions that persist across future interactions, not just a single bad prompt in a single session. The underlying environment the agent depends on could be altered and left that way.
Why “Prompt Injection” Doesn’t Tell the Whole Story
Prompt injection has become one of the most talked about risks in AI security. The idea is simple enough: an attacker places instructions somewhere an AI system can see them, and the system follows those instructions instead of behaving as intended.
The NemoClaw case points to something broader than that. The security problem is not always inside the prompt. It can live in the infrastructure around the AI entirely.
Think about how a traditional application gets secured. Nobody protects an application by locking down only the user interface. A serious security review also looks at authentication, APIs, network connections, databases, permissions, operating systems, logging, and monitoring, along with the risk carried by third-party dependencies. AI systems need that same mindset. The model is only one piece of a much larger system.
The Security Boundary Around AI Keeps Expanding
As AI becomes more capable, the number of components it touches grows with it. An AI agent might move through a chain that runs from the user to the agent itself, to the underlying model, to APIs, into business applications, into company data, and out to external tools. Every link in that chain is a potential security boundary. If one component is compromised, the effects can travel to the next one.
This is why AI security cannot simply mean “we put the agent in a sandbox.” A sandbox reduces risk. It does not automatically make everything inside or around it trustworthy.
Applying the Zero Trust Lesson to AI
This is where a familiar cybersecurity principle becomes newly relevant. One of the core ideas behind Zero Trust is straightforward: never assume something is trustworthy simply because of where it sits. That principle applies surprisingly well to AI infrastructure.
Being local, internal, sandboxed, or behind the firewall is not, on its own, a reason to trust a component. The better approach is to authenticate it, authorize it, restrict it, monitor it, and log it. The right question is not “is this inside our environment?” It is “what is this component allowed to communicate with, and what is it allowed to do?”
Why This Matters to the Business, Not Just IT
For a company experimenting with AI agents, this can initially sound like a highly technical concern. The business implications are actually quite direct.
Picture an AI agent with access to internal documents, customer records, email, customer relationship management (CRM) systems, financial information, source code, and cloud infrastructure. That access exists because the agent needs it to do useful work. But if an attacker can manipulate the agent, or the infrastructure it depends on, those same permissions become part of the attack path.
The more capable an AI agent becomes, the more its surrounding security architecture matters. Every organization deploying one should be able to answer a simple question before it goes into production: if an attacker gains control of this agent, what can they reach?
Sandboxing Still Has a Place
None of this means sandboxing is a bad idea. Isolation remains a genuinely useful control. The mistake is treating one control as an entire security strategy.
A sandbox can limit what an application touches, but organizations still need to think through network exposure, authentication, authorization, API security, secrets management, identity, data access, model integrity, logging, monitoring, and software supply chain risk. Security has always worked best as a layered system of controls, and AI should not be treated as an exception.
A Newer Layer to Think About: Agent-to-Model Communication
Most of the public conversation about AI security focuses on the interaction between a user and an AI system. The NemoClaw case is a reminder that agent-to-model, agent-to-API, agent-to-tool, and agent-to-data interactions deserve their own scrutiny.
- Who can make the request
- What they can request
- Which model is being used
- What data is being passed along
- What tools the agent can call, and what permissions it holds
- Whether the request can be monitored and suspicious behavior detected
- Whether the action can be stopped before it completes
These used to be theoretical questions. They are quickly becoming part of the standard security architecture for any AI-powered business.
What Business Leaders Can Do
Nobody needs to become an AI security specialist to start asking the right questions. Organizations deploying or piloting AI agents can start with a few practical steps:
- Build an inventory of every system, application, API, and data source the agent can reach — it is impossible to assess risk for access nobody has mapped.
- Apply least privilege, so the agent does not automatically inherit the same access as the employee who built it.
- Secure the APIs the agent communicates through with proper authentication, authorization, and monitoring.
- Review the infrastructure that hosts and serves the model, not just the model’s behavior.
- Put monitoring in place so unusual agent activity gets flagged rather than missed.
- Plan for compromise from the start, by asking what happens if this specific agent is taken over, then building controls around that answer.
The Bigger Shift Underway
Early conversations about AI security focused almost entirely on whether someone could trick the model. That question still matters, but the conversation has widened. Now the questions include what the model can access, what the agent is capable of doing, what happens if the agent is compromised, whether an attacker can manipulate the infrastructure around it, and whether abnormal behavior can be caught and stopped before it causes damage.
Those questions move AI security out of prompt engineering and into familiar cybersecurity territory: identity, access control, network security, application security, data security, monitoring, incident response, and supply chain security. The difference is that AI agents can chain many of these components together and act far faster than a person ever could.
The Bottom Line
The NemoClaw vulnerability is a useful reminder that AI security does not stop at the model, and it does not stop at the agent either. It extends across the entire environment that allows the AI system to operate. As organizations hand AI agents more access and more autonomy, the security architecture built around those agents becomes just as important as the model itself.
The goal is not to slow down AI adoption. It is to make sure that when AI is given access to something valuable, there are real controls wrapped around that access.
That is the question worth answering before AI agents become deeply embedded in day-to-day business operations. The organizations that get the most value out of AI will not be the ones that hand their agents the most access. They will be the ones that understand exactly what their agents can do, where they can go, and what happens when something goes wrong.