How to Decide What AI Agents Can Access and Change

Give each AI agent its own identity and limit what it can read, change, and do without approval.

Publication desk · · 8 min read
Cover illustration for “How to Decide What AI Agents Can Access and Change”
Agentic AI Containment · November 6, 2026 · 8 min read · 1,862 words

Agentic workflow automation for enterprise needs task-level authority. Deciding what AI agents can access and change means giving each agent a verifiable identity, limiting its reach, and separating permission to read from permission to act. Those decisions must be enforced on every tool call and revised whenever the agent’s work changes.

Why traditional access control breaks when agents enter the picture

Traditional identity and access management assumes a predictable caller, either a person with a job description or a service account following the same code path. Agents break that assumption by planning at runtime. An agent with the same goal on different days may use different tools in a different order. Fixed permissions can therefore block legitimate work or get widened until they offer little restraint. The workflow no longer defines a reliable boundary.

Email, web pages, tickets, and documents can contain instructions crafted to redirect it, a technique called prompt injection. If the agent has broad rights, the redirected action can use those rights. Delegation complicates accountability further because a child agent or external tool may receive work without preserving the original user’s limits. The chain of authority becomes hard to follow.

Credentials can also outlast the work they support. An API key that remains valid after a task ends leaves a standing grant of access without a clear purpose. Even while the task is active, a valid identity does not make every request safe. An authenticated agent can still attempt something that conflicts with policy, data sensitivity, or business context.

The four layers every agent permission decision touches

An agent’s authority spans four layers, which are identity, tools, data, and autonomy. Identity establishes which account is acting and whether it represents the agent itself or a specific user. Tools define the functions, APIs, plugins, or MCP servers it may invoke and the operations they expose. Data limits the records, documents, and fields it may retrieve or modify. Autonomy sets which actions it may finish on its own and which need a person’s approval.

These layers constrain different parts of the same decision. Access to a tool does not imply access to every record behind it, and access to a record does not imply permission to change it. The model chooses tools based on text that can be wrong, ambiguous, or manipulated, while the surrounding controls limit the consequences. A useful authority ladder moves from Read to Recommend to Execute to Approve, with each step justified by the work and its risk.

Giving every agent its own verifiable identity before any access decision is made

When several agents use one API key or service account, their activity cannot be reliably separated, their permissions cannot be tuned individually, and revoking one can disrupt all of them. Each agent needs a machine identity of its own. Its identity record should include a unique identifier, a named owner, an approved purpose, a defined trust level, a lifecycle state, and credential and expiration details. The owner is the person responsible when the agent’s behavior or scope needs to change.

The next distinction is whose authority it uses. An autonomous agent acts as itself with application permissions, as a nightly inventory reconciliation agent might do. A delegated agent acts for a signed-in user and should never exceed that user’s access. For delegated work, the user’s token should be exchanged for a task-scoped token that names both user and agent and is bound to one API. The original token should not reach the agent or its tools directly, and further delegation must narrow permissions or leave them equal.

In February 2026, NIST’s National Cybersecurity Center of Excellence published a concept paper covering identification, authorization, auditing, non-repudiation, and controls against prompt injection for software and AI agents. Public comments closed April 2, 2026. That work addresses more than assigning an account name, including how actions can be attributed and authority established. Once identity is clear, the next decision is which resources that identity may reach.

Matching the access control model to what the agent's task actually requires

A pilot often needs data before the rules for its access are ready. Someone supplies a working database credential, and its broad reach becomes permanent because nobody revisits it after the pressure eases. The connection works, but its scope is wrong. Governed access must be in place when the agent launches. The right model depends on how predictable the task is and whose authority the agent uses.

Role-based access control, or RBAC, gives an agent a predefined role with fixed rights. It suits narrow, repeatable work. As tasks grow, though, roles can become too broad, while a separate granular role for each version of a task adds more roles to keep up to date. Attribute-based access control, or ABAC, evaluates agent, user, resource, and context attributes on each request. That fits work across different data sets or sensitivity levels, though the policies need care to keep them up to date.

Fine-grained authorization, or FGA, grants access only to particular resources. An agent can receive permission for specific projects, repositories, or documents without receiving everything around them. Database access needs the same care over which rows and columns the agent can reach, with access tied to the user it acts for. A governed MCP server can grant only what that user is entitled to see, unlike a shared credential that exposes everything its connection can reach. Across finance, HR, sales, and support, each connection should have only the access its task requires.

The hard line between reading and acting, and why it must be enforced at every tool call

Permission to read an invoice and permission to approve it belong to different classes of risk. Each needs its own grant of authority. A task that begins as read-only research may later attempt to update a record or send information outside the company. Its starting intent cannot determine what the system allows throughout the session.

Authorization must run on every tool call. A user may be removed, a role downgraded, or a resource reshared after the session begins, making an earlier access decision stale. Tool binding adds a separate constraint by exposing only a curated, approved set of tools and actions. A governed protocol layer can make an access decision on each request. The protocol applies existing policy.

The OWASP GenAI Security Project identifies excessive agency as a recognized risk and recommends minimizing extension permissions, executing extensions in the user’s context, and enforcing authorization in downstream systems. The model should not police its own authority. In a finance workflow, this means an agent allowed to review contract terms does not automatically gain the right to approve payments based on them.

Tiering approval requirements by what an action can and cannot be undone

Diagram: Four Tiers of Agent Action by Risk and Reversibility. Visualizes: Show four vertically stacked tiers that map agent actions to their authorization requirements, based on reversibility and consequence.

Authorization is necessary, but it is not the final question. Whether the action can be undone if it is wrong also matters. Reversibility gives the autonomy layer a practical basis for deciding when a human must approve. It also distinguishes work that can run freely from work that needs a deliberate pause. Four tiers make that distinction explicit.

Search, reading, summaries, and drafts fall in the low tier. These actions are allowed and logged without an approval gate. The medium tier covers creating or editing records where the change can be undone. These actions are allowed and logged, but also rate-limited.

The high tier covers external email, deletion, and export, and these actions need out-of-band approval before they can run. The critical tier covers payments, permission changes, bulk deletes, and production deploys, requiring approval plus step-up authentication. At the critical tier, nothing changes without a person’s yes. That requirement belongs in the tool bindings and workflow logic from the start. It is not a safeguard to add after the agent is live.

Approval gates do create friction, but the tiers concentrate it where the consequences warrant it. Even at high volume, reads, drafts, and summaries can run on their own without waiting in the same queue as payments. Every tier needs logging, even when no approval is needed. The record must show what the agent accessed, when, and under whose authority. Without it, the organization cannot reconstruct how an allowed read or an approved change contributed to an outcome.

Applying the framework task by task across the workflows where agents touch money

In accounts payable, an agent can autonomously read invoice data, contract terms, and supplier records, with that activity logged. It can then flag invoices above contract price, find duplicate payments, or point out vendors with unused credits. Those findings do not require authority to move money. Updating a payment record, initiating a transfer, or releasing a hold requires human approval before execution.

In vendor and renewal management, an agent can read and analyze contract expiration dates, usage data, and pricing across systems on its own. Accepting renewal terms, extending a contract, or canceling a seat moves into the change or critical tier, depending on value and reversibility. Finding an unused license is not permission to remove it. To remove a seat, the agent needs a separate, explicit grant to make that change and a named approver.

Revenue operations has its own version of the distinction. An agent reading usage signals, support tickets, and renewal dates across CRM and support systems can identify a customer at risk without creating an irreversible consequence. Preparing a follow-up draft stays within the recommend tier. Sending it reaches a customer and cannot be unsent, so it is a high-tier action requiring explicit approval.

These workflows show why enterprise-wide permissions are too blunt. Read access may need to span systems to uncover an opportunity, while change access should be limited to the specific action needed to pursue it. The gaps between HR, finance, sales, and support can hold findings that matter because no single team sees both sides. Those gaps also make authority harder to assign.

Governing the agent across its full lifecycle, not just at launch

Decisions made at launch fit the scope approved at that time. As work changes, permissions can drift, and agents created for projects can remain active after their purpose ends. At launch, its identity, owner, purpose, scope, and approval tiers need to be recorded. During operation, every tool call needs authorization, audit records need to be maintained, and anomalous behavior needs to be flagged.

A scope change requires review before the new task begins. Otherwise, yesterday’s permissions become the unexamined starting point for tomorrow’s work. The humans managing agents need the same discipline, with rights matched to their roles. A compliance reviewer may need to read agent outputs without being able to edit workflows or deploy to production. Separate development and production environments allow changes to knowledge, workflows, and permissions to be tested before they affect live operations.

Named owners also need a way to pause or revoke an agent without waiting for IT intervention. At decommission, credentials must be revoked, access withdrawn, and the agent’s decision history retained by the organization. That history should preserve which findings were approved, which were rejected, and what outcomes followed. Keeping it with the organization rather than the tool vendor gives future permission decisions a basis in what the work actually produced.

More in Agentic AI Containment