.png)
Securing the Enterprise Agentic Era
As agentic systems access your data, use your tools, and act with your authority, it's important to have robust security controls in place that are beyond prompt safeguards.
Enterprise AI is rapidly shifting from simply answering questions to getting work done. In 2023, the first wave of individual chatbots and workplace AI could summarize documents, draft emails, and generate code. Now, the next generation connects to inboxes, file storage, business applications, and workflows. Instead of simply suggesting actions, these systems can easily take them.
This ability creates enormous value, but it also changes the nature of the risk. If a chatbot gives a bad answer, it might waste an employee’s time. But an agent with broad access can now send that answer to a client, update a live system, leak confidential information, or start a transaction before anyone notices. For enterprise leaders, the security question is no longer, “Can we trust the model’s answer?” It is also, “What can this system access, and what happens if the model is wrong or manipulated?”
Agentic AI Changes the Trust Boundary
In traditional applications, instructions can be separated from data; the code defines what the application can do, and the system treats all user input as data to process. The innate authentication, authorization, and application logic create explicit boundaries between the two.
But large language models do not separate data in the same way. The system prompt, a user’s request, an email, a retrieved document, a webpage, and any result returned by a connected tool can all become part of the model’s working context. The labels and instructions may help the model prioritize the information, but it does not operate like a hard authorization boundary.
This distinction matters because agentic systems routinely consume content the organization does not control and where malicious instructions can be hidden. If the model follows it, the content has crossed a boundary that conventional software would normally identify and enforce.
This type of vulnerability is known as prompt injection and generally appears in two forms. Direct prompt injection happens when a user deliberately enters malicious commands into the system attempting to override the agent’s intended behaviour. The more concerning scenario is an indirect prompt injection, where malicious instructions are hidden in content the agent later reads, such as an email, document, form entry, or webpage. The employee using the agent may never see the instruction, but the agent may still treat it as something to follow. As agents gain more autonomy, permissions, and operational reach, this kind of manipulation can quickly turn from a model-level issue into a material business incident or breach.
When Content Becomes Instruction
Recently, ShareLeak demonstrated how this risk can emerge in an ordinary enterprise workflow. Security researchers submitted malicious instructions through an external SharePoint form processed by an agent built with Microsoft Copilot Studio. The agent treated the form entry as part of its instructions, accessed customer records in a connected SharePoint list, and emailed that data outside the organization.
This incident is not an isolated case. In September 2025, EchoLeak showed that a single email could get Microsoft 365 Copilot to leak internal data without the user doing anything, while getting past Microsoft's prompt injection filters. Additionally, another case showed how a malicious public issue led an AI agent connected to GitHub to publish data from the user's private repositories. There was no bug for GitHub to patch. Every tool worked as designed.
There is a real lesson. The risk is not tied to one platform or vendor. It appears when an agent can receive outside information, access sensitive business data, and act on the organization's behalf. Each instruction or capability may serve a legitimate purpose, but together they can turn a routine interaction into a serious business incident.
Managing Agentic Risk
So how should you build agents that deliver value without giving them unchecked authority?
Start by building security boundaries into the design, not as a pre-launch review.
- First, limit each agent to the data, tools, and actions its task requires, and set transaction, rate, or spending limits where appropriate.
- Second, place an independent check between untrusted content and consequential actions such as payments, deletions, external communications, production changes, or access grants. Show the decision maker exactly what will happen and never let an agent approve or bypass its own action.
- Finally, record what the agent accesses and does, test it with misleading and unexpected inputs, assign an accountable owner, and give that owner a reliable way to pause it. The goal is not to eliminate every failure. It is to ensure that when an agent is misled or behaves unexpectedly, your organization can detect the problem, contain the impact, and recover quickly.
Navigating Agentic Risk with Arcurve
Agentic AI does not require abandoning innovation. It requires applying familiar security disciplines to a new, less deterministic component. No model or prompt can guarantee an agent will never be manipulated, so the work is in the system around it: making manipulation hard to exploit, limited in impact, and visible when it happens.
Arcurve helps organizations identify where agentic risk enters a workflow, map the paths between untrusted content and consequential actions, and design controls that preserve business value, from permission, and connector reviews to adversarial testing before an agent goes live.
As your organization moves from AI experimentation to agents that act, it’s important to assess the model's authority before increasing its autonomy. Arcurve can help you determine what the agent should reach, what it should never do alone, and which controls are needed before it becomes part of the business. Contact us today to build a secure and trusted AI system across your organization and avoid unnecessary and costly pitfalls.
Sources and Further Reading
OWASP Top 10 for Large Language Model Applications
ShareLeak: Taking the Wheel of Microsoft's Copilot Studio
GitHub MCP Exploited: Accessing Private Repositories via MCP
EchoLeak: The First Real-World Zero-Click Prompt Injection Exploit in a Production LLM System





