Transitioning from conversational interfaces to fully operational environments, the concept of “agentification” introduces new complexities and vulnerabilities. Beyond well-documented risks like prompt injection via documents processed by the agent, misunderstandings and erroneous manipulations now pose fresh threats that are often overlooked in many organizations’ security policies.
For years, agent-based tools remained the domain of developers. Claude Code, GitHub Copilot, Cursor, and Codeium functioned in environments where the user is inherently technical. These users analyze logs, understand system calls, and monitor terminal behavior; when something goes awry, they can spot it. This technical familiarity isn’t merely a convenience; it serves as a vital first line of defense. However, since the beginning of 2025, a new generation of agent tools has explicitly targeted business functions. Financial directors, HR teams, legal departments, and executive management are now within the adoption scope. Tools like Claude Cowork, Microsoft 365 Copilot, Notion AI, and Gemini for Workspace no longer require users to grasp what happens behind the scenes. This is precisely their commercial promise—and also their main security challenge.
The concern is no longer whether agents will make errors or be manipulated; rather, it centers on who will detect these issues and how quickly. Experiential knowledge gained from prompt injection attacks, context manipulations, and silent data exfiltrations makes it clear that attack vectors are not merely theoretical. They have been documented in laboratories, exploited in proof-of-concept demonstrations, and observed in real-world scenarios. What is changing now is the scale of deployment and the increasing vulnerability of the exposed perimeter.
What a Business Agent Actually Executes on Your System
An AI agent deployed in a business setting operates within a Docker container, a Windows Subsystem for Linux (WSL) instance, or an isolated process in Linux, typically running a Python interpreter or a Node.js runtime. It is in this environment that orchestration frameworks execute, loading dozens of transitive dependencies, many of which lack comprehensive maintenance and vulnerabilities histories. The agent also incorporates automation scripts in Python or Bash, which can be invoked at the model’s command to launch system processes, manipulate files, or call APIs without user confirmation.
The network and application connectors represent the broadest exposed surface. The Microsoft Graph API enables the agent to programmatically access Exchange messaging, Outlook calendars, OneDrive files, Teams channels, and Azure AD groups, relying on the OAuth rights of the authenticated user, without a visible session in the interface. The Model Context Protocol (MCP)—an open specification published by Anthropic in late 2024—standardizes connections between the agent and local or remote tools, covering file system reading, shell command execution, and calls to third-party MCP servers exposing business functions. REST or GraphQL connectors link the agent to the organization’s ERP and CRM systems, allowing access to SAP via RFC or BAPI, Salesforce via REST API v58, ServiceNow through the Table API, and Workday via SOAP Web Services. IMAP and SMTP clients allow the agent to read and send emails directly from the mail server. Web automation tools like Playwright, Puppeteer, or Selenium can be embedded to interact with web interfaces not covered by structured APIs. Each of these channels represents a potential entry point for malicious instructions and a possible exit point for data exfiltration.
The Sandbox as a Security Fiction
The immediate instinctive response to concerns about agent security is often isolation. Agents are confined within Docker containers, executed under Windows Subsystem for Linux, or have restricted system rights. This reasoning appears sound: if the agent operates within a bubble separate from the host system, its potential damages remain contained. While this intuition is correct in its premises, it falters in its conclusions.
An effective agent is, by definition, a connected agent. To read a shared file, it must access the file system. To send an email, it must call a messaging API. To update a dashboard, it must write to a database. To orchestrate workflows, it needs to open network connections to external services. Each of these capabilities serves as a bridge between the isolated environment and the broader information system, and every bridge constitutes a potential attack surface. Thus, the question is not whether the agent can escape the sandbox; it must do so to be useful. The paramount question becomes what an attacker could potentially transit through these bridges if they manage to manipulate the agent’s instructions.
The reality of underlying software layers exacerbates this scenario. Modern agents depend on Python libraries, XML parsers, HTTP proxies, IMAP clients—components typically written in C or C++ with vulnerability histories spanning decades. The anecdote of the null byte exemplifies this issue more effectively than any theoretical argument. An attacker injecting a null character (x00) into a string processed by a traditional parser can trigger silent truncation of the file path, potentially granting access to resources that should remain off-limits. This is not a flaw in the language model but rather a vulnerability in a C library dating back to the 1990s, reactivated as a modern agent inputs data it was never designed to validate. The modernity of the agent interface stands upon foundations whose code remains unrevised.
Prompt Injection as an Operational Attack Vector
Prompt injection represents the most directly applicable form of attack against agents deployed in business environments. The principle is straightforward: an attacker embeds malicious instructions within a shared document, an incoming email, a webpage loaded in the agent’s context, or a form field. The agent, unable to distinguish between legitimate commands from its operator and malicious instructions within the data it processes, executes both.
The sophistication of documented attacks has rapidly advanced since the first demonstrations in 2023. Indirect injections—those propagated through third-party data rather than the user interface—are proving particularly challenging to detect and counter. A financial document shared via a collaborative platform may contain, in white text on a white background or coded within metadata, a command instructing the agent to transfer the contents of the last ten emails to an external address. The user merely sees a loading bar while the agent obeys what it interprets as a valid instruction, triggering no alerts.
This vector is even more formidable in business environments, where agents have access to particularly sensitive information. A general-purpose productivity agent connected to email, calendars, shared documents, and ERP tools within a finance department possesses a level of access that few information systems would grant to any single human user. The segmentation of rights—an essential principle of security—is inherently bypassed by the very nature of the agent, which requires extensive integration to be effective. Structurally, the agent is an over-privileged user.
Background Processes are Concealed by Design
The shift of agent tools to business functions not only alters the profile of exposed data but fundamentally changes users’ ability to detect and respond to issues. A developer observing abnormal behavior within their work environment has a frame of reference for interpreting it. They know what a legitimate API call looks like, notice when a process unusually consumes CPU, and can inspect terminal logs to identify suspect outputs. Such skills are honed through daily interaction with their tools.
In contrast, a finance director or HR manager using a general-purpose productivity agent does not possess the same instincts or tools. Their interface is designed to obscure complexity, not to expose it. Background processes are inherently invisible. The agent’s actions unfold in software layers beyond their purview, and they remain oblivious to their existence. Their criteria for evaluating functionality boils down to whether a result is produced within a reasonable time frame. If an agent generates an accurate report while simultaneously exfiltrating data, the business user has no means to detect it through mere observation of the interface.
The nature of the data at stake further amplifies this disparity. Development environments expose API keys, source code, and access tokens—sensitive assets whose value is primarily technical. Business environments, however, expose entirely different types of data: unpublished financial projections, personal employee data, restructuring plans, contract negotiation details, and access to ERP systems— all of which are directly accessible to a properly authenticated agent. The differential value for an attacker is considerable, and the likelihood of detection inversely correlates with the sensitivity of the concerned data.
Designing Control and Visibility Mechanisms
The technical response to the challenge of agent security exists in broad strokes. More rigorous isolation techniques, cryptographic signing of instructions, exhaustive logging of agent actions, and language models specializing in injection detection are either in development or already available in experimental implementations. The real issue is not the absence of technical solutions; rather, it lies in how these are integrated with the user experience, which determines the commercial value of agent tools.
An agent that requires user confirmation for every action would lose its primary function. An agent that generates detailed logs of each operation produces a volume of information that no business user would read. An agent with segmented access to the point where it cannot accomplish its assigned tasks creates friction without providing value. The challenge of security ergonomics is to devise control and visibility mechanisms that restore true supervisory capabilities to the user without disrupting the automation flow that justifies deployment.
Several promising pathways are emerging from recent efforts by leading security teams. The notion of a “minimal footprint” (action scope coherent with the assigned task) is beginning to be formalized as a design principle. The goal is for the agent to request not permanent access but rather temporary, revocable permissions limited to the duration of the task and strictly necessary scope. Differential logging, which records not each action but deviations from learned baseline behavior, offers a method to reduce alert volumes without losing weak signals. Conditional human validation triggered only when the agent approaches predefined thresholds (data volume accessed, scope of irreversible action, access to sensitive categories) allows for maintaining autonomy on routine tasks while keeping a checkpoint on high-risk actions.
What Security Teams Must Anticipate Now
The adoption of general-purpose productivity agents in French companies is accelerating. Microsoft 365 Copilot has already been deployed in thousands of organizations, with tools from Google, Anthropic, Notion, and their local integrators following suit. In most cases, this deployment is occurring ahead of adjustments to security policies, incident response procedures, and auditing frameworks. Security teams are confronted with a tool whose attack vectors do not align with the threat categories they have learned to manage.
Three initiatives warrant immediate attention. The first is creating an inventory of agent access in production—identifying which agents have access to which resources, with what rights, and under what revocation conditions. This mapping, apparent for human user accounts in any serious IAM repository, is nearly nonexistent for agents in most organizations. The second priority is defining access policies tailored for agents, which involves prohibiting permanent rights, automating revocation post-task execution, logging access to sensitive data categories, and deploying alert mechanisms for atypical behaviors. The third focus area is training business users—not to understand the technical aspects of agents but to recognize signals that should prompt them to suspend ongoing operations and alert their security team. This is not technical training; it is about fostering vigilance, akin to the anti-phishing training that has gradually reshaped user behavior in handling suspicious emails.
Autonomous agents are not a threat in themselves; they are tools whose attack surface is poorly understood by those shaping deployment policies and remains opaque to those who use them daily. Bridging this gap will be the task of the coming period, before significant incidents compel urgent reactions.



