In 2025, AI agents thrived in experiments. In 2026, enterprises are discovering what it takes to operate them within real workflows. When agents begin operating autonomously across multiple systems, clear boundaries around what they can see, do, or share become essential.
Agents are information-intensive by nature and issue more searches and retrieve more data than the average user ever would. That scale multiplies their value—and just as quickly multiplies risk.
An agent that can “do anything” poses an enterprise liability. Without enforced access controls, agents create unauthorized access and exposure at scale.
Having spent years building systems where access control actually matters, I’ve repeatedly come to the same conclusion: The only identity model that scales safely is the delegate identity model.
Why agents cannot roam freely
The moment an enterprise gives work to an agent, it also provides access. That’s where the real challenge begins. You can’t hand an agent the keys to every system. But you also can’t manually build a new permission map for every task an agent might attempt.
In short: AI has a permissions problem.
Unless managed through a platform that enforces identity and access controls, agents focus on task completion. They don’t distinguish between allowed and appropriate task completion—only between accessible and not accessible.
If the fastest path to finish a report runs through a sensitive repository—an HR compensation file or an M&A data room—the agent will take it, if the system permits access.
At the machine scale, that master-key behavior poses a real risk. A single task can pull restricted data into its active working state, where it can be surfaced, summarized, or shared with unauthorized users.
At that point, the violation has already occurred. You can’t redact or unsee information after retrieval. This is why permissions must be enforced at the moment of access—not after generation, not after review, and not through prompts.
The proven path with identity as a proxy
The good news is that enterprises solved a version of this issue decades ago.
Most employees never think about the rules at all—which is the point. You don’t see financials if you work in marketing because the system is designed to prevent that. Identity, permissions, and auditability are built into the platform rather than left to individual judgment.[1]
The same principle is the cleanest way to scale autonomous agents. Agents should operate as delegates. A delegate carries a badge instead of a master key.
In practice, that means an agent makes every request—every query, every document fetch, every tool call—using the actual human identity of the person who asked it to act. All the same constraints, policies, and permission boundaries are already in place.
When you do this, a few things fall into place.
- Access stays scoped: The agent retrieves only what the requesting user is allowed to access across SharePoint, Salesforce, ticketing systems, and the long tail of legacy tools enterprises still depend on.
- Governance stays intact: A separate “AI security layer” doesn’t try to guess what’s sensitive after the fact. You reuse the controls you have already invested in: roles, policies, group membership, and access control lists.
- The context stays clean: If the user can’t see the file, the agent can’t pull it in, and sensitive content never enters the reasoning path. You’re not asking the model to be responsible, but you are making it incapable of being irresponsible.
When access isn’t auditable
In a regulated enterprise, preventing unauthorized access to information is only half the battle. The other half is proving that a security breach didn’t happen, or, if it did, exactly how and where it started.
This is where the master key model fails most spectacularly. When an agent uses a generic service account or root access, its actions become a black box.
If an HR file is leaked, you can’t tell if it was the agent acting on its own, an outside actor’s prompt-injection attack, or a disgruntled employee’s deliberate query.
By using delegate identity, you turn security into a system of record. Because the agent carries the human’s virtual badge, every tool call and data fetch is automatically logged against that specific user’s identity.
The anchor of the agentic enterprise
Implementing delegated identity end-to-end is not a trivial engineering problem. Propagating authenticated human identity across agents, enterprise systems, and content platforms requires careful coordination across security, infrastructure, and application layers.
This identity-based approach doesn’t eliminate complexity—identity and permissions have long been among the hardest problems in enterprise software, and AI only amplifies them. But the model itself doesn’t change. The same identity-based controls that enterprises already rely on to manage human access can also govern agents.
For decades, identity was the foundational anchor of enterprise security. AI doesn’t change that reality but does validate it.
As we move from simple chatbots to autonomous agents, the goal is to ensure that AI respects the silos we’ve already built. Treat agents as delegates rather than master users, to ensure that our control over our data remains intact as the technology evolves.
Eric Barroca is the founder and CEO of Vertesia.