A permission playbook does not configure an AI agent by itself. It gives the client team a clear set of business requirements that their administrator, developer or implementation partner can translate into platform settings, workflow checks and tests.

Permission design starts with a business decision: what may this agent read, recommend, change or commit the company to doing? Platform implementation is the separate work of enforcing that decision inside the systems the agent uses. A playbook can say that a refunds agent may issue up to $100 only after ownership, eligibility and remaining refundable balance are verified. The commerce platform, workflow tool or custom service still has to check those conditions before money moves.

That is what PermissionByDesign means by vendor agnostic. The method can be applied across platforms because the planning questions are the same: allowed action, required evidence, routine limit, approval trigger, unavailable approver behavior, execution record and recovery path. The implementation path depends on the agent platform, the connected systems, the permissions assigned to the agent and the client’s configuration.

Consider a fictional retailer, Northstar Outfitters. Its returns agent may explain refund eligibility, recommend a refund amount and issue a refund of up to $100 only after it verifies the customer’s ownership of the order, policy eligibility and the remaining refundable balance. Refunds above $100 require approval from the support operations manager. Customer confirmation that the person wants a refund is not the same as employee authorization to exceed the limit. If the payment tool returns an uncertain outcome, the agent must pause and verify the transaction before another attempt. These are illustrative rules, not a universal refund policy.

Salesforce Agentforce: actions need enforcing logic

In Salesforce Agentforce, a permission plan can help the team decide which actions the agent should have and which data it should be allowed to use. Salesforce guidance for Agentforce Apex action design emphasizes building actions with clear input and output expectations, business logic and defensive handling. That matters because an agent instruction such as “refund only when eligible” is not the same as a Flow or Apex check that prevents the refund action from running when the evidence is missing or the amount is outside the allowed range.

For the Northstar example, access permissions might limit what order and payment fields the agent can read. An agent action might request a refund. Flow or Apex logic could check ownership, eligibility, refundable balance and amount before execution. A separate approval path could route refunds above $100 to the support operations manager. The exact identity and permission model can vary by agent type, channel and Salesforce configuration, so the implementation team has to confirm which user, service account or runtime context is actually used.

Microsoft Copilot Studio: flows and approvals can carry the rules

Microsoft Copilot Studio can connect agents to flows and other actions. Microsoft’s documentation describes agent flows for automating processes and connecting to business systems. A permission playbook gives the team the conditions those flows should check before completing an action. The flow might verify the order, look up the refundable balance and stop when required evidence is unresolved.

The approval distinction is important. Asking the customer, “Do you want to proceed with this refund?” is customer confirmation. It records the customer’s request or consent to continue. It does not authorize an exception to policy. A refund above Northstar’s $100 limit would still need the support operations manager’s approval before execution. Depending on the client’s Microsoft environment, that might be represented through an approval step, a workflow queue or another business process. The playbook defines the requirement; the Microsoft administrator or implementation partner decides how to enforce and test it.

Amazon Bedrock Agents: return control can create a review point

Amazon Bedrock Agents use action groups to connect an agent to operations. AWS also documents a “return of control” option, where the agent can return the proposed action and parameters to the client application instead of invoking the action directly. That can be useful when a business wants application-side checks before execution. It does not automatically implement Northstar’s refund rules, approval process or duplicate-action controls. The application still has to decide what to check and what to do next.

In practice, the agent might propose a refund request with order ID, customer ID and amount. The client application could then verify the remaining refundable balance, check whether the amount is within the $100 routine limit, route exceptions to the support operations manager and block a retry when payment status is unknown. Returning the proposal gives the application an opportunity to enforce the plan. It is not the enforcement by itself.

Developer-built agents: tool calls can be checked before execution

For a developer-built agent, the enforcement point is often the code that handles tool calls. A tool call is a request by the agent to use an external function, API or service. The application can inspect the request before executing it. The OpenAI Agents SDK human-in-the-loop guide, for example, describes approval patterns that let developers pause before running a tool and require a person or process to approve it.

A developer could use the Northstar playbook to build checks into the refund tool wrapper: verify order ownership, verify eligibility, calculate remaining refundable balance, require approval above $100 and pause if the payment result is unknown. Some teams may choose to manage authorization rules separately from application code. Open Policy Agent provides policy tooling, including material on agent tool calling. Cedar is another policy language and authorization model, with documentation at docs.cedarpolicy.com. These technologies can help organize authorization decisions, but they still require integration. Teams that connect agents to tools through Model Context Protocol servers still need to design how authorization works for those servers and clients; the MCP authorization specification documents authorization concepts for HTTP-based transports. They do not turn a business playbook into a working refund system automatically.

OpenAI Dots: managed settings can reflect part of the plan

OpenAI describes Dots as always-on agents in ChatGPT. For a managed assistant, a permission plan can inform the instructions, app permissions and Custom Rules that the account owner or workspace administrator uses. OpenAI’s Dots FAQ describes privacy, safety and permission concepts for Dots, including app permissions and Custom Rules.

That does not mean a PermissionByDesign playbook can be imported as a universal Dots policy. It also does not mean custom instructions provide the same enforcement as application code that blocks a payment API call. If a Dot is used to help employees reason about refund requests, the playbook can guide its instructions and boundaries. If the agent connects to tools that can change records or trigger external actions, the client’s workspace settings, app permissions and connected-system controls still need to match the intended authority.

What the implementation team must establish

After receiving a permission playbook, the client’s implementation team needs to map each planned action to the actual system action that could carry it out. “Issue a refund” might mean a payment API call, a commerce-platform workflow, a CRM action, a support-tool macro or a request sent to another service. The team must identify the trusted data used for each check, such as order ownership, eligibility, refundable balance, payment destination and transaction status.

The team also needs to identify who can approve exceptions, how approval is recorded, how execution is blocked until requirements are satisfied and how the behavior will be tested. For Northstar, a test should prove that a $90 eligible refund can proceed after required evidence and customer confirmation, a $125 refund routes to the support operations manager, a missing refundable-balance check pauses execution and an unknown payment outcome does not trigger an immediate retry. A written plan makes the requirements explicit. The implementation team must then verify which requirements the connected systems can enforce and identify any gaps before deployment.

Some rules are settings, some are code and some may be unsupported

The implementation path will not be the same in every platform. Some requirements may be handled with existing access settings. Some may be handled with workflow logic, approval steps or tool wrappers. Some may require custom development. Some may be unsupported in the client’s current platform or plan. There is no universal import mechanism established by the documentation reviewed for this guide. A JSON export from a planning tool can make the plan easier to process, compare and store, but it does not make the plan executable or enforceable across platforms.

This is where the permission playbook is most useful. It gives the business owner and technical team the same checklist: action, evidence, limit, approval, unavailable-approval behavior, tool-failure behavior and record. It helps the implementation team ask precise questions instead of guessing what the business intended.

Sources

To put these decisions into a practical format, use the Permission Plan Builder or explore the Permission Plan Review. The value is a clear set of requirements your team can apply, test and verify inside the systems it actually controls.