
Most cybersecurity discussions over the past decade have focused on scale. More users, more devices, more data moving across systems.
AI agents introduce a different kind of problem.
They don’t just process requests. They interpret inputs, make decisions, and sometimes take action across systems. In enterprise settings, that can include internal tools, data, and workflows.
That’s where things get tricky. Risk is no longer just about infrastructure or access. It also comes down to how the system processes inputs and what it does with them.
When systems start acting independently
AI agents are built to reduce manual work. They can respond to customers, trigger workflows, and move across tools without much human input.
That’s exactly what makes them useful. But it also makes them harder to control.
Once a system can take action on its own, the question changes. It’s not just “is it secure?” but “can it be pushed into doing something it shouldn’t?”
Most security models assume things are fairly clear:
- Inputs are structured
- The intent is obvious
- Behavior is predictable
In reality, AI agents don’t always work like that. They deal with messy inputs, rely on context, and generate responses based on probability.
That makes them more flexible, but also less predictable.
Prompt injection is already showing up
Prompt injection is one of the more immediate risks.
Instead of breaking the system, it plays with how the system interprets instructions. An attacker can shape an input to change what the agent prioritises or how it responds. Sometimes that leads to data exposure. Sometimes it leads to actions that were never meant to happen.
Also Read: The agentic shift: Why AI agents are rewriting the rules of ERP software in Singapore and Malaysia
A few examples:
- A support agent surfacing internal information
- A workflow agent pulling data it shouldn’t have access to
- A coding assistant producing insecure outputs
What makes this harder is that the input often looks normal. There’s no obvious “attack pattern.” It’s just a request that gets misinterpreted.
This is not just a theoretical concern. Even companies building these systems acknowledge the limitation.
OpenAI recently noted that prompt injection is unlikely to be fully solved, comparing it to scams and social engineering on the web. In their work on AI browsers, they also pointed out that giving agents the ability to interact with the open web expands the attack surface in ways that are difficult to fully control.
That reflects a broader reality. The goal is not to eliminate these attacks entirely, but to reduce how often they succeed and limit the impact when they do.
Data leakage is often unintentional
AI agents get better with more context. That usually means access to internal documents, previous conversations, and connected systems.
That same access creates risk.
In many cases, data leakage doesn’t come from a breach. It comes from how the system is set up and how it responds in context.
Sensitive information can show up because:
- Access is too broad
- Too much context is being pulled in
- The system misreads what the user is asking
As discussed in my earlier article, trust is becoming central to how digital platforms operate. With AI systems, that trust depends heavily on how data is handled in everyday interactions.
Existing security models only go so far
Most traditional security approaches assume systems behave in predictable ways.
AI agents don’t.
They rely on context, probability, and ongoing interaction. That creates gaps in how we usually secure systems.
For example:
- Input validation is harder when everything is natural language
- Access control gets messy when context keeps changing
- Monitoring becomes less useful when behaviour isn’t consistent
Even logs don’t tell the full story. You can see what happened, but not always why.
Also Read: AI agents are entering investment banking, but is the industry ready?
Securing behaviour, not just systems
This is where the approach needs to shift.
It’s less about locking everything down and more about making sure the system behaves within clear boundaries.
In practice, that means:
- Being explicit about what agents are allowed to do
- Adding checks for higher-risk actions
- Limiting access to only what’s needed
- Watching patterns over time, not just single outputs
In real-time environments, this becomes even more important. Systems are making decisions in milliseconds, often with direct user interaction.
The goal is not to restrict what the system can do, but to make sure it behaves predictably under real-world conditions.
What this means going forward
AI agents are already being used across support, operations, and internal tools. That’s only going to increase.
Before scaling them further, teams need to be clear on a few basics:
- What can this agent access?
- What can it do without oversight?
- How does it behave when things are unclear?
These aren’t edge cases. This is how these systems operate day to day.
At that point, security isn’t just about preventing access. It’s about ensuring the system does what it’s supposed to, even when the inputs aren’t perfect.
As CISO, the questions I focus on are the same ones every team deploying agents should be asking: what can this agent access, what can it do without a human in the loop, and how does it behave when inputs are ambiguous or adversarial? In practice, this usually comes down to having clear limits, visibility into how the system behaves, and a way to step in when something does not look right.
—
Editor’s note: e27 aims to foster thought leadership by publishing views from the community. You can also share your perspective by submitting an article, video, podcast, or infographic.
The post The new cybersecurity threat: Why AI agents are the wild card in enterprise security appeared first on e27.




