← Blog

CIBA for AI Agents: Human Approval on a Separate Device

Parminder Singh
Parminder Singh··6 min read
Summarize with AI

Client-Initiated Backchannel Authentication gives an AI agent workflow a standards-based way to request authentication and consent on a separate device. A defensible deployment records the initiating agent and authorizing user, requested action and auth_req_id, expiry and delivery mode, plus the final result while keeping tool authorization and execution as separate controls.

Platform & Architectureai-securityagentic-aiidentity-and-authorizationzero-trustarchitecture
CIBA for AI Agents: Human Approval on a Separate Device

Client-Initiated Backchannel Authentication separates the device where an AI agent starts a request from the device where a person authenticates and grants consent. The agent-facing application calls an OpenID Provider over a backchannel. A phone can carry the approval while the agent waits on a laptop or server. That separation gives teams a protocol-specific approval artifact instead of a generic "human reviewed it" field.

The implementation must prove which agent initiated the request and which person approved it. It must also show what they saw, when the request expired, and how the client received the outcome. CIBA supplies that flow, while your application still owns action authorization and execution.

TL;DR

  • CIBA lets an agent workflow request authentication and consent on a separate device without a browser redirect on the initiating device.
  • Record the initiating agent and authorizing user, requested action and auth_req_id, expiry and delivery mode, plus the final result.
  • Test denial and expiry, plus replay and incorrect polling. Also test mismatched transaction context before production.
  • Keep CIBA, tool authorization, tool execution, and routed LLM inspection as distinct security boundaries.

CIBA separates the consumption and authentication devices

The OpenID CIBA Core 1.0 specification, finalized on September 1, 2021, defines direct communication between a Relying Party and an OpenID Provider without redirecting through the user's browser. It names the initiating surface the consumption device and the device used for authentication and consent the authentication device.

That shape fits an agent workflow. Auth0's CIBA documentation identifies an AI agent as a possible initiating user and lists human approval for an agent action as a CIBA use case. The person receiving the request is the authorizing user.

Picture a laptop showing an agent paused beside a pending payment and a phone lighting up with the merchant, amount, and requested action. The laptop carries the workflow while the phone gives the person an independent place to authenticate and decide.

This protocol-specific flow complements a broader human-in-the-loop agent design. The generic design owns pause state, reviewer authority, preserved arguments, and safe resume. CIBA owns the backchannel authentication transaction and its result.

The transaction needs a stable evidence chain

A CIBA client sends an authenticated request to the OpenID Provider's backchannel authentication endpoint. The request identifies the intended user through an approved hint and can carry contextual values such as a binding message. After validation, the provider returns an auth_req_id and an expires_in lifetime. For poll mode, it also returns an interval controlling how often the client should ask for the result.

The provider then engages the authorizing user on the authentication device. The person authenticates and grants or denies consent there. The client receives the outcome through one of three modes chosen during registration:

  • Poll: The client asks the token endpoint for the result, respecting the returned interval.
  • Ping: The provider sends a notification containing the transaction identifier, and the client retrieves the tokens from the token endpoint.
  • Push: The provider delivers the authentication result to the registered client notification endpoint.

Treat those messages as one transaction. The acceptance record should connect client identity and initiating agent, intended authorizing user and request context, auth_req_id and creation time, expiry and delivery mode, plus the consent result and token retrieval outcome. A workflow run ID can join that record to the application without turning it into the protocol's security identifier.

Approval text should name the action a person is authorizing

CIBA proves that an OpenID Provider ran an authentication and consent flow. The surrounding application determines how clearly the requested action is described. A screen that says "Allow agent" gives a reviewer too little context for a high-impact decision.

I would reject that screen in a production review. The approval should identify the consequential action using stable, human-readable fields: payee and amount for a payment, repository and branch for a deployment, customer and data category for an export, or account and permission for an access change. Keep sensitive detail to the minimum the person needs, since the authentication device and its notification channel create their own privacy exposure.

The context also needs integrity across the pause. Preserve the action arguments associated with the CIBA transaction, then verify them before execution. If the amount, destination, scope, or tool changes after approval, require a new authorization decision. The AI agent post-authentication gap appears when a valid identity event is treated as permission for a later action whose details have drifted.

CIBA authentication and consent finish before tool execution. The tool server or business application still decides whether the approved identity may perform the exact operation. Its logs should name the operation and arguments, authorization decision and executor, plus the result.

A release gate should include negative CIBA tests

A successful phone approval proves the happy path. Production acceptance needs deliberate failures around transaction binding and timing. Run the tests against the actual provider, client registration, notification endpoint, and mobile channel that will ship.

Begin with identity and context by sending a request for the wrong authorizing user and confirming that no useful approval can be completed. Alter the displayed transaction context in a controlled environment and verify that the mismatch stops execution. Deny one request and preserve the provider result plus the application's terminal state.

Then test time and delivery behavior by letting an auth_req_id expire. Poll faster than the returned interval and confirm the client handles the provider's response without creating duplicate workflow transitions. Deliver a ping twice and retry a callback, then verify idempotent processing. Reuse a completed transaction identifier and expect rejection. For push mode, validate the registered HTTPS endpoint and the client notification token handling specified by the deployment.

Finish with recovery. Restart the waiting application after the person approves but before the result is processed. The workflow should recover the pending transaction once and maintain the original action context. It should also avoid executing twice. Keep one screenshot from the authentication device, with private data redacted, beside the machine-readable event sequence. That pair makes the test understandable during an audit six months later.

The approval record has clear ownership boundaries

Four owners contribute evidence to one agent action. The OpenID Provider records authentication, consent, delivery mode, and token issuance. The agent application records the initiating workflow, pending state, action context, and resume decision. The tool or downstream service records authorization and execution. A routed model control records only model traffic that crossed its inspected HTTP path.

Preserve correlation values across those systems without pretending one log observed the whole event. Use auth_req_id for the CIBA transaction and the workflow run ID for application state. Tool request IDs identify the executing service, while a later model-request ID identifies the LLM route. An investigation can join them by explicit references and timestamps.

This separation also keeps incident conclusions honest. A CIBA approval can be genuine while a later tool request contains changed arguments. The agent can bypass the intended approval state before a tool executes correctly. A model request can also bypass the inspected route. Each condition has a different control owner, so the acceptance pack should include a failure test for every handoff.

DeepInspect

CIBA authentication, consent, provider notification, token issuance, and tool execution sit outside DeepInspect's boundary. DeepInspect has no basis to prove that a CIBA approval occurred or remains valid. Those claims belong to the OpenID Provider and application records, plus the downstream service records.

The boundary begins only when the approved workflow later sends an authenticated HTTP request to an LLM endpoint deliberately routed through DeepInspect. For that request, DeepInspect can evaluate application-supplied identity and role, prompt classification, destination, and versioned policy, then produce an independent decision record. The identity-aware AI gateway architecture shows the context that must reach this later request boundary.

Book a technical deep dive at deepinspect.ai.

Frequently asked questions

Can an AI agent initiate a CIBA flow?

Yes. Auth0 documents an AI agent acting on a user's behalf as a possible initiating user and gives human approval for an agent action as a CIBA use case. The registered client sends the backchannel authentication request. The authorizing user receives the request on the authentication device and decides there.

Does CIBA authorize the downstream tool call?

CIBA supplies authentication and consent through the OpenID Provider. The application and tool service own authorization for the exact operation, arguments, target, and timing. Preserve the approved action context and compare it with the execution request. Material changes should create a fresh decision rather than inherit an earlier approval.

Which CIBA delivery mode fits an agent workflow?

Poll is straightforward when the client can wait and respect the provider's interval, while ping tells the client when to retrieve the result. Push sends the result to a registered endpoint. The right choice depends on provider support, callback exposure, recovery behavior, and the team's ability to process retries idempotently. Test the selected mode under duplicate and delayed delivery.

What belongs in a CIBA acceptance record?

Record the registered client and initiating agent, workflow and intended authorizing user, human-readable action context and auth_req_id, creation time and expiry, delivery mode and consent result, plus the token retrieval result and correlation to later application and tool events. Avoid storing tokens or private keys in the evidence pack.