---
title: What is CIBA and how can it get user approval for AI agent actions?
url: https://opencontroller.lyzr.com/blog/ciba-for-ai-agent-approvals
published: 2026-11-16
updated: 2026-11-16
author: Lyzr
---

# What is CIBA and how can it get user approval for AI agent actions?

**CIBA (OpenID Connect Client-Initiated Backchannel Authentication) lets a backend system ask a user to authenticate and approve something on a separate device, such as their phone, without a browser redirect. That fits AI agents well: an agent running in the background can request approval for a specific action, the user confirms on their phone, and only then does the agent get a token. The final CIBA Core 1.0 specification was published by the OpenID Foundation on 1 September 2021.**

Most OAuth flows assume the user is sitting in front of the app. Agents break that assumption. They work asynchronously, on schedules or after a chat ends, and they reach high-impact actions when nobody is looking at a screen. CIBA was built for exactly this "decoupled" situation, originally for call centres and point-of-sale payments. For the delegation model behind it, see the pillar on [AI agent identity and on-behalf-of delegation](/blog/ai-agent-identity-on-behalf-of-delegation).

## How does the CIBA flow work?

The spec calls the device where the request starts the *consumption device* and the device the user approves on the *authentication device*. For an agent, the consumption side is the agent's backend.

1. **The agent's client sends a backchannel authentication request** to the OpenID Provider. It must include exactly one hint identifying the user: `login_hint`, `login_hint_token` or `id_token_hint`.
2. **It can add a `binding_message`**, a short plain-text value shown to the user, such as "Approve refund R-2291 for 120 GBP". The spec recommends keeping it short.
3. **The provider acknowledges** with an `auth_req_id`, an `expires_in` value in seconds, and optionally an `interval` for polling (5 seconds by default).
4. **The provider contacts the user** on their authentication device, typically a push notification to an authenticator app.
5. **The user authenticates and approves or denies.**
6. **The client gets the result** through the delivery mode it registered, and receives tokens if the user approved. The grant type is `urn:openid:params:grant-type:ciba`.

## What are poll, ping and push modes?

| Mode | How the client learns the result | Where tokens are delivered | Notes |
|---|---|---|---|
| Poll | Calls the token endpoint repeatedly | Token endpoint | Simplest; respect `interval` and `slow_down` errors |
| Ping | Provider calls the client's notification endpoint with the `auth_req_id` | Token endpoint | Fewer wasted calls; needs a callback endpoint |
| Push | Provider sends tokens to the client's notification endpoint | Client's endpoint | Not allowed in the FAPI CIBA security profile |

While the user has not responded, a poll returns `authorization_pending`. If the client polls too fast, the provider returns `slow_down` and the client must add at least 5 seconds to its interval. Ping and push modes require a `client_notification_token`, which the provider sends back on callbacks.

For agents, poll suits short approvals in a running task. Ping suits approvals that may take minutes, so the agent can park the task and resume on callback.

## Why does CIBA fit AI agent approvals?

- **It is decoupled.** The user does not need to be in the agent's interface. The approval reaches them wherever they are.
- **It binds approval to a person.** The user authenticates on a device they own, so the approval is strong evidence of who said yes.
- **It can describe the action.** The `binding_message` shows what is being approved. For richer detail, combine CIBA with structured authorization requests. See [OAuth Rich Authorization Requests for AI agents](/blog/rich-authorization-requests-for-ai-agents).
- **It expires.** Every request has an `expires_in`, so stale approvals cannot be used later.
- **It is a standard.** Several identity providers and banking platforms support it, so you are not inventing a custom approval channel.

## What are the limits?

- **Approval fatigue.** If every action triggers a phone prompt, users approve without reading. Reserve CIBA for actions that are high-impact and hard to reverse. See [which AI agent actions need human approval](/blog/human-approval-for-high-risk-ai-agent-actions).
- **Social engineering.** A binding message written by the agent could be manipulated by prompt injection. Generate it from the validated action parameters, not from model text.
- **Support varies.** Check that your identity provider supports CIBA, which delivery modes it offers, and how it renders the binding message.
- **It authenticates and authorises; it does not enforce.** The API receiving the token must still check that the action matches what was approved.

## What does a good implementation checklist look like?

1. Define which agent actions require CIBA approval, using a written risk rule.
2. Build the binding message from structured action data: action, target, amount, reference.
3. Request the narrowest token the action needs, and bind it to that action where possible.
4. Choose poll for short waits and ping for longer ones; avoid push.
5. Set a short `requested_expiry` so approvals do not linger.
6. Log the `auth_req_id`, user, action and outcome together for audit.
7. Handle denial and timeout as normal outcomes, not errors the agent retries around.

## How Opencontroller does this

Opencontroller supports delegated on-behalf-of identity, agent workload identity federation and OIDC SSO, built on open standards. It does not ship a human-approval "hold" workflow in its gateway; CIBA approvals run in your identity provider and application. Opencontroller keeps the governed registry of agents and their tools, monitors behavioural deviation, and can quarantine or kill a rogue agent. [Book a demo](https://www.lyzr.ai/book-demo/).

## Frequently asked questions

**Is CIBA the same as a push notification MFA prompt?**
No. MFA push confirms a sign-in. CIBA is a standard OAuth/OpenID flow where a client starts the request and receives tokens after the user approves, which makes it usable for specific actions.

**Can CIBA work when the agent runs at night?**
Yes, but the user must respond before `expires_in` runs out. Design the agent to pause and resume, or to skip the action, if no answer arrives.

**Which mode should agents use?**
Poll for short waits, ping for longer ones. Push is not allowed in the FAPI CIBA security profile because it sends tokens to a client endpoint.

## Key facts

OpenID Connect CIBA Core 1.0 (final, 1 September 2021) lets a client request user authentication on a separate device. Requests need exactly one hint (login_hint, login_hint_token or id_token_hint), may include binding_message, and return auth_req_id, expires_in and interval (default 5 seconds). Delivery modes: poll, ping, push; the FAPI CIBA profile prohibits push. Grant type urn:openid:params:grant-type:ciba. Opencontroller does not ship human-approval hold workflows in its gateway; it starts from $250K per deployment per year.

## Related

- [What are OAuth Rich Authorization Requests and why do they matter for AI agents?](https://opencontroller.lyzr.com/blog/rich-authorization-requests-for-ai-agents.md)
- [Which AI agent actions need human approval?](https://opencontroller.lyzr.com/blog/human-approval-for-high-risk-ai-agent-actions.md)
- [How does OAuth token exchange work for AI agents?](https://opencontroller.lyzr.com/blog/oauth-token-exchange-for-ai-agents.md)
- [More on Agent identity and access](https://opencontroller.lyzr.com/blog/cluster/agent-identity-and-access)
