AI agents

AI agent permissions: tools, approvals and action limits

Define AI agent permissions for tools, records, approvals and stopping conditions. Build an action contract and test the boundaries before delivery.

By Point of AI Editorial team

Published 15 min read · Updated

An agent can sound helpful while having more authority than its task requires. A support assistant that only needs to prepare a reply may be connected through an account that can change customer records, send messages and export unrelated data. Describing the assistant as supervised does not explain which of those actions it can actually perform.

AI agent permissions should begin with the job the agent is meant to do. Define the information it can read, the changes it can propose, the actions it can execute and the points where another person must decide. Make those boundaries specific enough to demonstrate in a test.

This article uses a fictional account assistant that prepares follow-up messages and proposes updates to meeting notes. It is an original design example. The action contract described here is a delivery document for the product and engineering teams, not a legal agreement, security certification or substitute for reviewing the implemented system.

Keep in mind

Key takeaways

  • Separate reading, proposing and committing changes in the tool and permission model.
  • Bind approval to the actual target, content and action being authorized.
  • Test rejected and interrupted actions against the connected systems, not just the reply.

Define the job before choosing the tools

Write a short task statement using observable outcomes. Our account assistant can find the relevant meeting notes, draft a follow-up and propose an update to an identified record. Sending the message and committing the update require the permissions and approvals defined for those actions.

List what the task excludes. The assistant is not authorized to modify arbitrary customer fields, search another team's workspace or contact a different recipient because that looks useful. Without explicit exclusions, a broad description such as “help manage accounts” can expand to cover actions nobody considered during the initial review.

Identify when the task is complete. A draft saved for review is a different outcome from a delivered message. The interface and the operating record should use language that reflects the actual result. This prevents a team from discussing a successful task while each person imagines a different level of execution.

Ask whether the behaviour needs an agent at all. A fixed sequence may be sufficient when the steps and decisions can be specified in advance. Anthropic's discussion of workflows and agents is a useful architectural reference for that distinction. It does not establish that an agent is appropriate for your task or prescribe the permission model of the surrounding business systems.

Reference: Building effective agents ↗

Build a tool inventory that explains effects

A tool inventory should say more than the integration's name. “CRM access” could mean reading a meeting note, editing a record or changing access settings. Give each available operation a description of what it reads, what it changes and which boundaries apply.

Prefer a task-specific interface when a broad capability would create unnecessary authority. For the account assistant, an operation that proposes a note update is easier to reason about than a general interface for modifying any record. The specification should expose the required fields and permitted record types so the intended operation can be checked.

Document the result a tool returns. Does a response confirm that a change was committed, report that work was queued or merely acknowledge receipt? The agent should not announce completion based on an intermediate result. Describe the failure and unknown-outcome states alongside the normal response.

Review the inventory with a person who understands each connected system. A product team may recognize that an assistant needs a meeting note, but the system owner can identify the relevant access model and unintended privileges. This conversation should happen before a convenient demonstration account becomes the assumed production identity.

Separate reading, proposing and committing

Read access, draft creation and committed changes should be distinct in the action contract. A user may be allowed to view a meeting note without being allowed to change its owner. An assistant may prepare a proposed edit without having permission to apply it. Make these distinctions explicit in the tool operations and the user experience.

Apply the principle of least privilege: grant the access necessary for the defined task and examine any additional authority separately. A convenient broad permission should have to justify its place in the design.

OWASP's excessive-agency guidance identifies unnecessary functionality, permissions and autonomy as sources of risk. It recommends limiting tool access and enforcing appropriate authorization in downstream systems. That is the basis for asking what the application can actually permit, rather than relying on a prompt that tells the model to be careful.

Illustrative permissions for an account assistant

Scroll to view all columns →

OperationPermitted scope in this exampleRequired evidence before continuing
Read meeting noteIdentified account records available to the userAccess is authorized for that record
Prepare follow-upDraft only, using the selected contextRecipient and supporting facts are visible
Propose note updateA defined set of note fieldsThe proposed difference can be reviewed
Commit updateThe approved record and versionCurrent authorization and matching approval
Send follow-upThe approved message and recipientCurrent permission and a valid send decision

The table is an illustrative starting point. Your application may have different roles, approval requirements and operations. Test the actual permission boundaries, including the case where a broad service account could technically perform an action that the product's user is not entitled to request.

Reference: LLM06:2025 Excessive Agency ↗

Preserve the user's scope through the whole request

An action should not gain authority simply because it passed through an agent. The connected systems need enough trustworthy context to determine who is requesting the operation and whether the target is within the permitted scope. The application design should explain where that context is established and checked.

For our example, selecting one account in the interface does not authorize a search across all accounts. A proposed note update should carry the intended record identity through approval and execution. The system must be able to reject a different target, even if a generated instruction asks for it confidently.

Consider the lifecycle of access. What happens when a user's role changes, an integration credential expires or permission is withdrawn while a task is waiting? Define which checks happen when the task starts and which must happen again before execution. An old approval should not silently override a current access decision.

Avoid placing credentials or unrestricted access details into a prompt as a way of carrying authority. The agent can receive the information necessary to perform its task while the application manages credentials and authorization separately. Ask engineering to demonstrate how secrets, user scope and tool access are handled in the real execution path.

State exactly what an approval authorizes

“A person approved it” is incomplete without the object of that approval. For a follow-up message, the relevant object includes the text, recipient and intended action. For a note update, it includes the record, proposed fields and the version the reviewer saw.

Show those details in the approval interface. A person should not have to infer that clicking “Looks good” will send a message rather than save a draft. Use a clear action label and give the reviewer a way to inspect the underlying information. Product feedback and permission to execute should remain distinguishable.

Define when approval becomes stale. A change to the recipient, target record or material content may require another review. Decide how long an approval remains useful when the surrounding business information can change. There is no single expiry rule for every task, but the rule for your workflow should be recorded and enforced.

Test a deliberately changed request. Approve one draft, alter a relevant field and attempt the action again in an appropriate test environment. The result should follow the specified rule, not the model's interpretation of the earlier conversation. This exercise makes approval a demonstrable control instead of a reassuring sentence in a proposal.

Keep retrieved content separate from authority

An account note can contain useful facts without being a trusted instruction source. The same is true of an email, web page or uploaded document. If the assistant encounters text that asks it to change its task, the application still needs to preserve the original authorization boundaries.

Consider a note containing an instruction to send information to an unrelated address. The team should be able to show that the content cannot grant permission to change recipients or expand record access. A warning in the user interface does not replace controls on the operation that would perform the action.

Include this situation in the test plan for the intended environment. Use controlled examples that represent the material the system will encounter, and inspect which tool calls are proposed or executed. Check the final effect as well as the assistant's visible reply. A refusal message is not sufficient evidence if an unauthorized side effect already occurred elsewhere.

Keep the discussion specific to the implementation. Prompt design, input handling and tool authorization can all contribute to the response, but no single generic instruction demonstrates that the whole system is protected. Ask for the controls, known limits and test evidence that apply to your connected tools and business data.

Validate the action the system is about to perform

Before a tool executes, the application needs to check the proposed operation against its rules. A well-formed request can still target the wrong record or contain a value outside the permitted scope. Syntax and business authorization are related checks, but they are not the same check.

For the account assistant, useful questions include whether the record belongs to the permitted workspace, whether the selected field can be changed and whether the update still matches the approved proposal. The destination system may enforce some of these rules. Others may belong in the integration layer. The action contract should identify where each decision is made.

Explain how a rejection returns to the task. The agent may be allowed to correct a missing non-sensitive argument, ask the user for clarification or stop. It should not repeatedly alter a rejected request until a broad tool accepts it. Define which corrections are within the task and which require another decision from the user.

Review tool descriptions with the people who will test them. Clear names, required fields, effect descriptions and error responses reduce ambiguity in the proposed interface. They do not establish security by themselves, but they make it easier to examine whether the agent is choosing an appropriate operation and whether the application handles it as intended.

Define stopping conditions for incomplete tasks

An agent needs a useful outcome when it cannot finish. In this example, it can stop when a required record is inaccessible, when the proposed action exceeds its authority or when a tool fails beyond the agreed recovery rules. The user should receive the task state and the reason another decision is needed.

Set boundaries on continued work. Depending on the task, these might include a time budget, a permitted number of attempts or a limit on repeated tool failures. Choose values according to the operating requirements and document why they are appropriate. A stopping rule is not a universal performance benchmark.

Specify whether the agent can leave partial work. A draft message can remain available for review, while an uncertain update may require reconciliation with the destination. Give each partial result an accurate label. Avoid presenting an interrupted run as completed simply because the agent produced a plausible final paragraph.

Anthropic discusses environmental feedback, checkpoints and stopping conditions in its architectural treatment of agents. Our action-contract approach applies that discussion to a concrete delivery review. The useful test is whether the implemented system returns control with enough information for someone to continue, investigate or cancel the task.

Reference: Building effective agents ↗

Keep an operational record without collecting everything

The person investigating a run needs to connect the request, proposed action, approval and confirmed result. A useful record can identify the tool, target, relevant version, decision and outcome. Which content must be retained depends on the task and the organization's access and retention rules.

Do not assume that logging every prompt and document is the safest option. That can create another store of sensitive material with its own permissions and maintenance burden. Decide what is necessary to investigate the operation, then review how that information is protected and who is allowed to inspect it.

Give everyday users a concise account of the result. They need to know whether the message was drafted, whether a note was updated and which parts require attention. Keep detailed diagnostic material available to the appropriate operators without forcing everyone to interpret a tool trace.

Make the record useful for a disputed outcome. If someone asks why a particular account note changed, the team should be able to identify the relevant authorization and the version that was applied. An explanation generated after the event is not a substitute for evidence of what the system actually requested and executed.

Test denied actions as carefully as successful ones

A permission review should include attempts that must not complete. Use cases involving the wrong account, a withdrawn permission, an altered recipient and a changed draft after approval. Define the expected result before running the exercise so a convincing assistant response cannot redefine success afterward.

Check the connected systems, not just the chat transcript. Was a record modified? Was a message sent? Did the task remain within its permitted scope? A system that says it stopped but still performs the action has not met the intended boundary. Keep the relevant operation evidence with the case record.

Add failures and interruptions. A timeout after a tool call may leave the effect uncertain. The system should follow the specified reconciliation or handoff path rather than treating the absence of a response as proof that nothing happened. Repeat the cases affected by a change to tools, permissions or approval handling.

Keep model quality and authorization separate in the evaluation. The assistant may choose the correct action but lack permission to execute it. It may also choose an irrelevant action that the application correctly rejects. Both observations are useful, because they point to different work in task design, model behaviour and enforcement.

Review one proposed change all the way through

Suppose the fictional assistant proposes adding a meeting summary to an account note. The user can edit that account's notes, the proposed fields are within scope and the reviewer approves the displayed difference. The application still needs to confirm that the action being executed matches that proposal and that current permission allows it.

If the agent changes the target record after approval, the previous decision no longer describes the action. The system should follow the contract's rule for that mismatch. A sentence explaining that the new record seems more appropriate cannot expand the authority granted by the user.

Next, let the user lose edit access while the request is queued. The test should establish whether the execution path respects the current authorization rule. This is different from asking whether the model remembers an earlier instruction. The boundary needs to hold at the point where the connected system accepts or rejects the change.

Finally, interrupt the operation after submission but before confirmation. Ask the team to show how the run reports the unknown outcome, how it checks for an applied update and what information reaches the operator. This connects permission design with recovery design: a validly authorized action can still have an uncertain result.

Keep the walkthrough with the action contract as a review scenario. It ties abstract terms such as approval, scope and supervision to a specific record, version and effect. When the team adds a new tool later, it has an example of the level of detail required to examine the change.

Related reading: Plan recovery for interrupted AI workflows

Use the action contract in the delivery review

Bring the task statement, tool inventory, permission table, approval rules and test cases into the same review. Ask the product owner, integration owner and delivery team to walk through one successful run and several blocked or interrupted runs. Record disagreements as design work to resolve, not assumptions to leave for launch day.

If you commission an AI agent development company, request the implemented boundaries and supporting evidence as deliverables. Identify who owns integration access, who can change the permitted tools and who reviews changes after handover. Clarify the difference between a prototype demonstrating tool use and a service ready for the intended operating environment.

Retain the action contract as a maintained document. A new tool, destination or user group can change what the system is capable of doing. Review the affected rules and repeat the relevant cases before assuming that the earlier approval still covers the expanded system.

The document earns its place when it helps someone answer a concrete question: can this agent perform this action, on this record, for this user, under these conditions? A clear answer comes from the task design, application controls and observed behaviour together. That is a stronger basis for delivery than describing the agent as autonomous or supervised without explaining either term.

Related reading: Compare AI agent development companies

Read the original thinking

Sources & further reading

This is original Point of AI analysis. The sources support the statements attributed to them. Hypothetical examples and suggested questions are editorial guidance.

  1. LLM06:2025 Excessive Agency ↗OWASP Gen AI Security Project · Checked November 13, 2026

    Supports minimal tool functionality and permissions, downstream authorization and approval of high-impact actions. The action-contract format is Point of AI's editorial recommendation.

  2. Building effective agents ↗Anthropic · Checked November 13, 2026

    Supports checking progress using environmental feedback and setting human checkpoints and stopping conditions. Originally published in 2024; referenced for architectural principles, not current product features.