An Approve button is not authorization.
A human can click “Approve,” and an AI agent can still have too much permission, execute different parameters than the reviewer saw, reuse an old approval, or continue after the user's authority has changed.
That distinction is becoming critical as AI agents move from answering questions to changing systems.
The enterprise question is no longer: “Can our agent ask a human before acting?”
It is: “Can we prove that the right person approved this exact action, under current policy, and that the agent received no more authority than the action required?”
That is the real job of asynchronous authorization for AI agents.
What is asynchronous authorization for AI agents?
Asynchronous authorization allows an agent to pause when it reaches a protected action, request authorization through a trusted channel, wait without keeping the entire process open, and resume only after a valid authorization decision is available.
The pattern is useful because agent workflows may run in the background, over long periods, across multiple tools, while the user is offline, or after the user's original session has ended.
OpenID Connect CIBA provides a standardized backchannel authentication model where the client can initiate authentication and later obtain the result through supported delivery modes such as polling, ping or push. See the OpenID Connect CIBA specification.
Recent IETF work on AI-agent authentication explores applying CIBA-style patterns to agent workflows requiring user confirmation. This material is an Internet-Draft rather than a finalized standard, which is important context for buyers evaluating emerging implementations. See the IETF AI-agent authentication draft.
The biggest buyer mistake: confusing confirmation with authorization
Imagine an AI agent proposes: “Transfer $8,400 from Account A to Supplier B.”
The user sees “Approve transaction?” and taps Approve.
What exactly was approved?
- Which agent made the request?
- On whose behalf was it acting?
- Which tool was requested?
- Which account?
- Which supplier?
- Which amount?
- Which currency?
- Which policy triggered approval?
- When does approval expire?
- Can it be reused?
- Did the executed transaction match the reviewed transaction?
If the system cannot answer those questions, the approval is closer to UI confirmation than enterprise authorization.
The architecture buyers should look for
A strong asynchronous authorization flow looks like: User intent → Agent proposal → Policy evaluation → Authorization request → Trusted user approval → Scoped authorization artifact → Revalidation → Execution → Audit evidence.
The model participates in the workflow. It should not control the entire authorization chain.
Eight capabilities an enterprise platform should prove
| Capability | Buyer question |
|---|---|
| Identity binding | Can the request be tied to the initiating user and agent? |
| Resource-level authorization | Can access be limited to the exact resource involved? |
| Parameter binding | Is approval tied to exact action arguments? |
| Out-of-band approval | Can approval happen through a trusted independent channel? |
| Short-lived authority | Does approval create narrow, expiring authority? |
| Replay protection | Can the same approval be used twice? |
| Durable pause/resume | Can workflows wait safely for hours or days? |
| Audit evidence | Can security teams reconstruct the complete decision? |
1. Bind authorization to the exact action
Never approve only: “Agent may use payment tool.”
Approve something closer to actor, agent, tool, target resource, amount, destination, expiration and request identifier.
The OWASP AI Agent Security Cheat Sheet recommends controls such as exact-action binding, minimum necessary permissions and independent authorization around sensitive agent actions.
This creates an important property: If the action changes, the authorization is no longer valid.
2. Approval should be independent of the agent
The agent should not be able to manufacture the evidence that approval occurred.
A trusted authorization component should verify approver identity, approver authority, request context, current policy, expiration and prior use.
Auth0 describes an asynchronous AI-agent approval model using CIBA and Rich Authorization Requests, where a user can approve sensitive actions through a trusted device and the agent receives permission only after approval. See Auth0's human-in-the-loop approval overview.
The implementation details vary by platform. The design principle does not: The agent asks. The authorization layer decides.
3. Separate authentication, authorization and approval
| Layer | Question |
|---|---|
| Authentication | Who is this user, service or agent? |
| Authorization | Is this principal allowed to perform this action? |
| Approval | Does an authorized person agree to this specific action now? |
A secure workflow may need all three.
4. Human approval should be triggered by policy
Not every action needs human review. Low-risk operations might continue automatically: search approved documents, retrieve a status, draft an email, calculate a value or prepare a recommendation.
High-impact actions may require fresh authorization: transfer money, send external communication, delete data, change access rights, approve a refund, modify production or disclose sensitive records.
See LuMay’s Human-in-the-Loop AI Agents: How to Design Approval Gates.
That article answers where to place the human gate. This article answers what must make the approval valid.
5. Use least privilege before asking for more approval
Human approval should not compensate for an over-permissioned agent.
If the agent only needs to submit a refund request, do not give it broad administrative access to the billing platform.
See LuMay’s AI Agent Permissions: How to Enforce Least Privilege for Tools.
6. Pause-and-resume must survive real-world delays
An approval may arrive 30 seconds later, three hours later, the next morning, or never.
The workflow must therefore preserve state outside the model session.
- authorization request ID;
- proposed action;
- normalized arguments;
- current workflow state;
- policy version;
- expiration;
- approval status.
Do not keep a process alive indefinitely waiting for a human.
7. Revalidate before execution
Suppose approval occurs at 9: 00 AM and execution occurs at 1:00 PM.
During those four hours, the user's role may have changed, the account may have closed, the transaction may already have happened, the price may have changed, policy may have changed or the request may have expired.
Approval is evidence of intent at one moment. Execution still needs a current-state check.
8. Make high-impact actions idempotent
Imagine the user approves a payment, the agent executes it, the network response is lost, and the agent retries.
Without idempotency, one approved action can become two payments.
See LuMay’s AI Agent Idempotency: Prevent Duplicate Actions When Tools Retry.
Authorization and idempotency solve different problems. You need both.
A useful buyer test: change the parameters after approval
During a proof of concept, try this:
Original request: Transfer $1,000 to Supplier A.
User approves.
Then modify it to: Transfer $10,000 to Supplier B.
A secure system should reject execution and request fresh authorization.
Seven adversarial tests every platform demo should include
| Test | Expected result |
|---|---|
| Change amount after approval | Reject |
| Change destination | Reject |
| Reuse approval | Reject |
| Approval expires | Reject |
| Approver loses permission | Re-evaluate or reject |
| Duplicate execution request | Execute at most once |
| Authorization service unavailable | Fail according to predefined safe policy |
Do not evaluate security using only the successful path shown by the vendor.
The audit record should tell the whole story
For each protected action, retain enough evidence to answer who initiated the workflow, which agent acted, what it proposed, which policy applied, why approval was required, who approved, what exact action was authorized, when authorization expired, what actually executed and whether execution succeeded.
A single field such as approved = true is not an audit trail.
What CIBA solves—and what it does not
CIBA is useful for decoupling the client initiating authentication from the user's interaction. That makes it relevant for agents that need approval while running asynchronously.
But buyers should avoid assuming that one protocol solves the entire agent-governance problem.
- resource authorization;
- tool permissions;
- action-level policy;
- parameter binding;
- workflow state;
- retries;
- idempotency;
- audit;
- authorization expiry.
A buyer scorecard
| Dimension | What good looks like |
|---|---|
| Identity | User and agent identity are explicit. |
| Fine-grained authorization | Resource/action scope is narrow. |
| Approval binding | Exact parameters are protected. |
| Approval channel | Independent trusted interaction. |
| Authorization artifact | Short-lived, scoped and non-reusable. |
| Workflow durability | Safe pause/resume. |
| Failure handling | Defined timeout and fail-closed behavior. |
| Execution safety | Revalidation and idempotency. |
| Audit evidence | Complete reconstructable record. |
| Developer integration | Works with real agent/tool architecture. |
Do not select purely by approval UI. The control model matters more.
Final perspective
The goal is not to insert more approval screens into AI workflows. The goal is to make authority precise.
The right user. The right agent. The right resource. The right action. The right parameters. The right moment.
And nothing more.
That is what enterprise buyers should demand from an asynchronous authorization platform.





